]> 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
wxArrayString::Sort() wasn't MT-safe even though it tried to
[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 #include <wx/power.h>
4063
4064
4065 #ifndef wxHAS_POWER_EVENTS
4066 // Dummy class and other definitions for platforms that don't have them
4067
4068 class wxPowerEvent : public wxEvent
4069 {
4070 public:
4071 wxPowerEvent(wxEventType evtType) : wxEvent(wxID_NONE, evtType) {}
4072 void Veto() {}
4073 bool IsVetoed() const { return false; }
4074
4075 virtual wxEvent *Clone() const { return new wxPowerEvent(*this); }
4076 };
4077
4078 enum {
4079 wxEVT_POWER_SUSPENDING,
4080 wxEVT_POWER_SUSPENDED,
4081 wxEVT_POWER_SUSPEND_CANCEL,
4082 wxEVT_POWER_RESUME,
4083 };
4084
4085 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4086 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4087
4088 #endif
4089
4090 #ifdef __cplusplus
4091 extern "C" {
4092 #endif
4093 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj = 0;
4095 wxSystemColour arg1 ;
4096 wxColour result;
4097 int val1 ;
4098 int ecode1 = 0 ;
4099 PyObject * obj0 = 0 ;
4100 char * kwnames[] = {
4101 (char *) "index", NULL
4102 };
4103
4104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4105 ecode1 = SWIG_AsVal_int(obj0, &val1);
4106 if (!SWIG_IsOK(ecode1)) {
4107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4108 }
4109 arg1 = static_cast< wxSystemColour >(val1);
4110 {
4111 if (!wxPyCheckForApp()) SWIG_fail;
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 result = wxSystemSettings::GetColour(arg1);
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj = 0;
4126 wxSystemFont arg1 ;
4127 wxFont result;
4128 int val1 ;
4129 int ecode1 = 0 ;
4130 PyObject * obj0 = 0 ;
4131 char * kwnames[] = {
4132 (char *) "index", NULL
4133 };
4134
4135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4136 ecode1 = SWIG_AsVal_int(obj0, &val1);
4137 if (!SWIG_IsOK(ecode1)) {
4138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4139 }
4140 arg1 = static_cast< wxSystemFont >(val1);
4141 {
4142 if (!wxPyCheckForApp()) SWIG_fail;
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = wxSystemSettings::GetFont(arg1);
4145 wxPyEndAllowThreads(__tstate);
4146 if (PyErr_Occurred()) SWIG_fail;
4147 }
4148 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj = 0;
4157 wxSystemMetric arg1 ;
4158 wxWindow *arg2 = (wxWindow *) NULL ;
4159 int result;
4160 int val1 ;
4161 int ecode1 = 0 ;
4162 void *argp2 = 0 ;
4163 int res2 = 0 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char * kwnames[] = {
4167 (char *) "index",(char *) "win", NULL
4168 };
4169
4170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4171 ecode1 = SWIG_AsVal_int(obj0, &val1);
4172 if (!SWIG_IsOK(ecode1)) {
4173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4174 }
4175 arg1 = static_cast< wxSystemMetric >(val1);
4176 if (obj1) {
4177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4178 if (!SWIG_IsOK(res2)) {
4179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4180 }
4181 arg2 = reinterpret_cast< wxWindow * >(argp2);
4182 }
4183 {
4184 if (!wxPyCheckForApp()) SWIG_fail;
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 resultobj = SWIG_From_int(static_cast< int >(result));
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj = 0;
4199 wxSystemFeature arg1 ;
4200 bool result;
4201 int val1 ;
4202 int ecode1 = 0 ;
4203 PyObject * obj0 = 0 ;
4204 char * kwnames[] = {
4205 (char *) "index", NULL
4206 };
4207
4208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4209 ecode1 = SWIG_AsVal_int(obj0, &val1);
4210 if (!SWIG_IsOK(ecode1)) {
4211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4212 }
4213 arg1 = static_cast< wxSystemFeature >(val1);
4214 {
4215 if (!wxPyCheckForApp()) SWIG_fail;
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = (bool)wxSystemSettings::HasFeature(arg1);
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4231 PyObject *resultobj = 0;
4232 wxSystemScreenType result;
4233
4234 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4235 {
4236 if (!wxPyCheckForApp()) SWIG_fail;
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4239 wxPyEndAllowThreads(__tstate);
4240 if (PyErr_Occurred()) SWIG_fail;
4241 }
4242 resultobj = SWIG_From_int(static_cast< int >(result));
4243 return resultobj;
4244 fail:
4245 return NULL;
4246 }
4247
4248
4249 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4250 PyObject *resultobj = 0;
4251 wxSystemScreenType arg1 ;
4252 int val1 ;
4253 int ecode1 = 0 ;
4254 PyObject * obj0 = 0 ;
4255 char * kwnames[] = {
4256 (char *) "screen", NULL
4257 };
4258
4259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4260 ecode1 = SWIG_AsVal_int(obj0, &val1);
4261 if (!SWIG_IsOK(ecode1)) {
4262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4263 }
4264 arg1 = static_cast< wxSystemScreenType >(val1);
4265 {
4266 if (!wxPyCheckForApp()) SWIG_fail;
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 wxSystemSettings::SetScreenType(arg1);
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 resultobj = SWIG_Py_Void();
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
4279 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4280 PyObject *obj;
4281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4282 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4283 return SWIG_Py_Void();
4284 }
4285
4286 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4287 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4288 return 1;
4289 }
4290
4291
4292 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4293 PyObject *pyobj = 0;
4294
4295 {
4296 #if wxUSE_UNICODE
4297 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #else
4299 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #endif
4301 }
4302 return pyobj;
4303 }
4304
4305
4306 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 PyObject *resultobj = 0;
4308 wxSystemOptions *result = 0 ;
4309
4310 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (wxSystemOptions *)new wxSystemOptions();
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj = 0;
4326 wxString *arg1 = 0 ;
4327 wxString *arg2 = 0 ;
4328 bool temp1 = false ;
4329 bool temp2 = false ;
4330 PyObject * obj0 = 0 ;
4331 PyObject * obj1 = 0 ;
4332 char * kwnames[] = {
4333 (char *) "name",(char *) "value", NULL
4334 };
4335
4336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4337 {
4338 arg1 = wxString_in_helper(obj0);
4339 if (arg1 == NULL) SWIG_fail;
4340 temp1 = true;
4341 }
4342 {
4343 arg2 = wxString_in_helper(obj1);
4344 if (arg2 == NULL) SWIG_fail;
4345 temp2 = true;
4346 }
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 resultobj = SWIG_Py_Void();
4354 {
4355 if (temp1)
4356 delete arg1;
4357 }
4358 {
4359 if (temp2)
4360 delete arg2;
4361 }
4362 return resultobj;
4363 fail:
4364 {
4365 if (temp1)
4366 delete arg1;
4367 }
4368 {
4369 if (temp2)
4370 delete arg2;
4371 }
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj = 0;
4378 wxString *arg1 = 0 ;
4379 int arg2 ;
4380 bool temp1 = false ;
4381 int val2 ;
4382 int ecode2 = 0 ;
4383 PyObject * obj0 = 0 ;
4384 PyObject * obj1 = 0 ;
4385 char * kwnames[] = {
4386 (char *) "name",(char *) "value", NULL
4387 };
4388
4389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4390 {
4391 arg1 = wxString_in_helper(obj0);
4392 if (arg1 == NULL) SWIG_fail;
4393 temp1 = true;
4394 }
4395 ecode2 = SWIG_AsVal_int(obj1, &val2);
4396 if (!SWIG_IsOK(ecode2)) {
4397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4398 }
4399 arg2 = static_cast< int >(val2);
4400 {
4401 PyThreadState* __tstate = wxPyBeginAllowThreads();
4402 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4403 wxPyEndAllowThreads(__tstate);
4404 if (PyErr_Occurred()) SWIG_fail;
4405 }
4406 resultobj = SWIG_Py_Void();
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return resultobj;
4412 fail:
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return NULL;
4418 }
4419
4420
4421 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj = 0;
4423 wxString *arg1 = 0 ;
4424 wxString result;
4425 bool temp1 = false ;
4426 PyObject * obj0 = 0 ;
4427 char * kwnames[] = {
4428 (char *) "name", NULL
4429 };
4430
4431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4432 {
4433 arg1 = wxString_in_helper(obj0);
4434 if (arg1 == NULL) SWIG_fail;
4435 temp1 = true;
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 {
4444 #if wxUSE_UNICODE
4445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4446 #else
4447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4448 #endif
4449 }
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return resultobj;
4455 fail:
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return NULL;
4461 }
4462
4463
4464 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj = 0;
4466 wxString *arg1 = 0 ;
4467 int result;
4468 bool temp1 = false ;
4469 PyObject * obj0 = 0 ;
4470 char * kwnames[] = {
4471 (char *) "name", NULL
4472 };
4473
4474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4475 {
4476 arg1 = wxString_in_helper(obj0);
4477 if (arg1 == NULL) SWIG_fail;
4478 temp1 = true;
4479 }
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 resultobj = SWIG_From_int(static_cast< int >(result));
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return resultobj;
4492 fail:
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return NULL;
4498 }
4499
4500
4501 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4502 PyObject *resultobj = 0;
4503 wxString *arg1 = 0 ;
4504 bool result;
4505 bool temp1 = false ;
4506 PyObject * obj0 = 0 ;
4507 char * kwnames[] = {
4508 (char *) "name", NULL
4509 };
4510
4511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4512 {
4513 arg1 = wxString_in_helper(obj0);
4514 if (arg1 == NULL) SWIG_fail;
4515 temp1 = true;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4520 wxPyEndAllowThreads(__tstate);
4521 if (PyErr_Occurred()) SWIG_fail;
4522 }
4523 {
4524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4525 }
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return resultobj;
4531 fail:
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = 0;
4542 wxString *arg1 = 0 ;
4543 bool result;
4544 bool temp1 = false ;
4545 PyObject * obj0 = 0 ;
4546 char * kwnames[] = {
4547 (char *) "name", NULL
4548 };
4549
4550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4551 {
4552 arg1 = wxString_in_helper(obj0);
4553 if (arg1 == NULL) SWIG_fail;
4554 temp1 = true;
4555 }
4556 {
4557 PyThreadState* __tstate = wxPyBeginAllowThreads();
4558 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4559 wxPyEndAllowThreads(__tstate);
4560 if (PyErr_Occurred()) SWIG_fail;
4561 }
4562 {
4563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4564 }
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return resultobj;
4570 fail:
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return NULL;
4576 }
4577
4578
4579 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 PyObject *obj;
4581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4582 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4583 return SWIG_Py_Void();
4584 }
4585
4586 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 return SWIG_Python_InitShadowInstance(args);
4588 }
4589
4590 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4591 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4592 return 1;
4593 }
4594
4595
4596 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4597 PyObject *pyobj = 0;
4598
4599 {
4600 #if wxUSE_UNICODE
4601 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #else
4603 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #endif
4605 }
4606 return pyobj;
4607 }
4608
4609
4610 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4611 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4612 return 1;
4613 }
4614
4615
4616 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4617 PyObject *pyobj = 0;
4618
4619 {
4620 #if wxUSE_UNICODE
4621 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #else
4623 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #endif
4625 }
4626 return pyobj;
4627 }
4628
4629
4630 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4631 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4632 return 1;
4633 }
4634
4635
4636 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4637 PyObject *pyobj = 0;
4638
4639 {
4640 #if wxUSE_UNICODE
4641 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #else
4643 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #endif
4645 }
4646 return pyobj;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651 PyObject *resultobj = 0;
4652 long result;
4653
4654 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 result = (long)wxNewId();
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_From_long(static_cast< long >(result));
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj = 0;
4670 long arg1 ;
4671 long val1 ;
4672 int ecode1 = 0 ;
4673 PyObject * obj0 = 0 ;
4674 char * kwnames[] = {
4675 (char *) "id", NULL
4676 };
4677
4678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4679 ecode1 = SWIG_AsVal_long(obj0, &val1);
4680 if (!SWIG_IsOK(ecode1)) {
4681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4682 }
4683 arg1 = static_cast< long >(val1);
4684 {
4685 PyThreadState* __tstate = wxPyBeginAllowThreads();
4686 wxRegisterId(arg1);
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 resultobj = SWIG_Py_Void();
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4698 PyObject *resultobj = 0;
4699 long result;
4700
4701 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4702 {
4703 PyThreadState* __tstate = wxPyBeginAllowThreads();
4704 result = (long)wxGetCurrentId();
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_From_long(static_cast< long >(result));
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4716 PyObject *resultobj = 0;
4717 int arg1 ;
4718 bool result;
4719 int val1 ;
4720 int ecode1 = 0 ;
4721 PyObject * obj0 = 0 ;
4722 char * kwnames[] = {
4723 (char *) "id", NULL
4724 };
4725
4726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4727 ecode1 = SWIG_AsVal_int(obj0, &val1);
4728 if (!SWIG_IsOK(ecode1)) {
4729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4730 }
4731 arg1 = static_cast< int >(val1);
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (bool)wxIsStockID(arg1);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4740 }
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 int arg1 ;
4750 wxString *arg2 = 0 ;
4751 bool result;
4752 int val1 ;
4753 int ecode1 = 0 ;
4754 bool temp2 = false ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "id",(char *) "label", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4762 ecode1 = SWIG_AsVal_int(obj0, &val1);
4763 if (!SWIG_IsOK(ecode1)) {
4764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4765 }
4766 arg1 = static_cast< int >(val1);
4767 {
4768 arg2 = wxString_in_helper(obj1);
4769 if (arg2 == NULL) SWIG_fail;
4770 temp2 = true;
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 {
4779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4780 }
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return resultobj;
4786 fail:
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return NULL;
4792 }
4793
4794
4795 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj = 0;
4797 int arg1 ;
4798 bool arg2 = (bool) true ;
4799 wxString arg3 = (wxString) wxPyEmptyString ;
4800 wxString result;
4801 int val1 ;
4802 int ecode1 = 0 ;
4803 bool val2 ;
4804 int ecode2 = 0 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 PyObject * obj2 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4813 ecode1 = SWIG_AsVal_int(obj0, &val1);
4814 if (!SWIG_IsOK(ecode1)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4816 }
4817 arg1 = static_cast< int >(val1);
4818 if (obj1) {
4819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4820 if (!SWIG_IsOK(ecode2)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4822 }
4823 arg2 = static_cast< bool >(val2);
4824 }
4825 if (obj2) {
4826 {
4827 wxString* sptr = wxString_in_helper(obj2);
4828 if (sptr == NULL) SWIG_fail;
4829 arg3 = *sptr;
4830 delete sptr;
4831 }
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = wxGetStockLabel(arg1,arg2,arg3);
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 #if wxUSE_UNICODE
4841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4842 #else
4843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4844 #endif
4845 }
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4853 PyObject *resultobj = 0;
4854
4855 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4856 {
4857 if (!wxPyCheckForApp()) SWIG_fail;
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 wxBell();
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4871 PyObject *resultobj = 0;
4872
4873 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4874 {
4875 if (!wxPyCheckForApp()) SWIG_fail;
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 wxEndBusyCursor();
4878 wxPyEndAllowThreads(__tstate);
4879 if (PyErr_Occurred()) SWIG_fail;
4880 }
4881 resultobj = SWIG_Py_Void();
4882 return resultobj;
4883 fail:
4884 return NULL;
4885 }
4886
4887
4888 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4889 PyObject *resultobj = 0;
4890 bool arg1 = (bool) true ;
4891 long result;
4892 bool val1 ;
4893 int ecode1 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 char * kwnames[] = {
4896 (char *) "resetTimer", NULL
4897 };
4898
4899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4900 if (obj0) {
4901 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4902 if (!SWIG_IsOK(ecode1)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4904 }
4905 arg1 = static_cast< bool >(val1);
4906 }
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 result = (long)wxGetElapsedTime(arg1);
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 resultobj = SWIG_From_long(static_cast< long >(result));
4914 return resultobj;
4915 fail:
4916 return NULL;
4917 }
4918
4919
4920 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4921 PyObject *resultobj = 0;
4922 bool result;
4923
4924 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (bool)wxIsBusy();
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 {
4932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *resultobj = 0;
4942 wxString result;
4943
4944 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4945 {
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 result = wxNow();
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 #if wxUSE_UNICODE
4953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4954 #else
4955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4956 #endif
4957 }
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxString const &arg1_defvalue = wxPyEmptyString ;
4967 wxString *arg1 = (wxString *) &arg1_defvalue ;
4968 bool result;
4969 bool temp1 = false ;
4970 PyObject * obj0 = 0 ;
4971 char * kwnames[] = {
4972 (char *) "command", NULL
4973 };
4974
4975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4976 if (obj0) {
4977 {
4978 arg1 = wxString_in_helper(obj0);
4979 if (arg1 == NULL) SWIG_fail;
4980 temp1 = true;
4981 }
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (bool)wxShell((wxString const &)*arg1);
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 {
4990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4991 }
4992 {
4993 if (temp1)
4994 delete arg1;
4995 }
4996 return resultobj;
4997 fail:
4998 {
4999 if (temp1)
5000 delete arg1;
5001 }
5002 return NULL;
5003 }
5004
5005
5006 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 PyObject *resultobj = 0;
5008
5009 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5010 {
5011 PyThreadState* __tstate = wxPyBeginAllowThreads();
5012 wxStartTimer();
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 resultobj = SWIG_Py_Void();
5017 return resultobj;
5018 fail:
5019 return NULL;
5020 }
5021
5022
5023 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5024 PyObject *resultobj = 0;
5025 int *arg1 = (int *) 0 ;
5026 int *arg2 = (int *) 0 ;
5027 int result;
5028 int temp1 ;
5029 int res1 = SWIG_TMPOBJ ;
5030 int temp2 ;
5031 int res2 = SWIG_TMPOBJ ;
5032
5033 arg1 = &temp1;
5034 arg2 = &temp2;
5035 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (int)wxGetOsVersion(arg1,arg2);
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_From_int(static_cast< int >(result));
5043 if (SWIG_IsTmpObj(res1)) {
5044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5045 } else {
5046 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5048 }
5049 if (SWIG_IsTmpObj(res2)) {
5050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5051 } else {
5052 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5054 }
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxString result;
5064
5065 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 result = wxGetOsDescription();
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 {
5073 #if wxUSE_UNICODE
5074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5075 #else
5076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5077 #endif
5078 }
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 wxMemorySize result;
5088
5089 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = wxGetFreeMemory();
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5097 return resultobj;
5098 fail:
5099 return NULL;
5100 }
5101
5102
5103 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5104 PyObject *resultobj = 0;
5105 wxShutdownFlags arg1 ;
5106 bool result;
5107 int val1 ;
5108 int ecode1 = 0 ;
5109 PyObject * obj0 = 0 ;
5110 char * kwnames[] = {
5111 (char *) "wFlags", NULL
5112 };
5113
5114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5115 ecode1 = SWIG_AsVal_int(obj0, &val1);
5116 if (!SWIG_IsOK(ecode1)) {
5117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5118 }
5119 arg1 = static_cast< wxShutdownFlags >(val1);
5120 {
5121 if (!wxPyCheckForApp()) SWIG_fail;
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (bool)wxShutdown(arg1);
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 {
5128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj = 0;
5138 int arg1 ;
5139 int val1 ;
5140 int ecode1 = 0 ;
5141 PyObject * obj0 = 0 ;
5142 char * kwnames[] = {
5143 (char *) "secs", NULL
5144 };
5145
5146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5147 ecode1 = SWIG_AsVal_int(obj0, &val1);
5148 if (!SWIG_IsOK(ecode1)) {
5149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5150 }
5151 arg1 = static_cast< int >(val1);
5152 {
5153 PyThreadState* __tstate = wxPyBeginAllowThreads();
5154 wxSleep(arg1);
5155 wxPyEndAllowThreads(__tstate);
5156 if (PyErr_Occurred()) SWIG_fail;
5157 }
5158 resultobj = SWIG_Py_Void();
5159 return resultobj;
5160 fail:
5161 return NULL;
5162 }
5163
5164
5165 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5166 PyObject *resultobj = 0;
5167 unsigned long arg1 ;
5168 unsigned long val1 ;
5169 int ecode1 = 0 ;
5170 PyObject * obj0 = 0 ;
5171 char * kwnames[] = {
5172 (char *) "milliseconds", NULL
5173 };
5174
5175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5176 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5177 if (!SWIG_IsOK(ecode1)) {
5178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5179 }
5180 arg1 = static_cast< unsigned long >(val1);
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 wxMilliSleep(arg1);
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_Py_Void();
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj = 0;
5196 unsigned long arg1 ;
5197 unsigned long val1 ;
5198 int ecode1 = 0 ;
5199 PyObject * obj0 = 0 ;
5200 char * kwnames[] = {
5201 (char *) "microseconds", NULL
5202 };
5203
5204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5205 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5206 if (!SWIG_IsOK(ecode1)) {
5207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5208 }
5209 arg1 = static_cast< unsigned long >(val1);
5210 {
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 wxMicroSleep(arg1);
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_Py_Void();
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj = 0;
5225 bool arg1 ;
5226 bool val1 ;
5227 int ecode1 = 0 ;
5228 PyObject * obj0 = 0 ;
5229 char * kwnames[] = {
5230 (char *) "enable", NULL
5231 };
5232
5233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5234 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5235 if (!SWIG_IsOK(ecode1)) {
5236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5237 }
5238 arg1 = static_cast< bool >(val1);
5239 {
5240 PyThreadState* __tstate = wxPyBeginAllowThreads();
5241 wxEnableTopLevelWindows(arg1);
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 resultobj = SWIG_Py_Void();
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj = 0;
5254 wxString *arg1 = 0 ;
5255 wxString result;
5256 bool temp1 = false ;
5257 PyObject * obj0 = 0 ;
5258 char * kwnames[] = {
5259 (char *) "in", NULL
5260 };
5261
5262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5263 {
5264 arg1 = wxString_in_helper(obj0);
5265 if (arg1 == NULL) SWIG_fail;
5266 temp1 = true;
5267 }
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 result = wxStripMenuCodes((wxString const &)*arg1);
5271 wxPyEndAllowThreads(__tstate);
5272 if (PyErr_Occurred()) SWIG_fail;
5273 }
5274 {
5275 #if wxUSE_UNICODE
5276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5277 #else
5278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5279 #endif
5280 }
5281 {
5282 if (temp1)
5283 delete arg1;
5284 }
5285 return resultobj;
5286 fail:
5287 {
5288 if (temp1)
5289 delete arg1;
5290 }
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296 PyObject *resultobj = 0;
5297 wxString result;
5298
5299 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 result = wxGetEmailAddress();
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 #if wxUSE_UNICODE
5308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5309 #else
5310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5311 #endif
5312 }
5313 return resultobj;
5314 fail:
5315 return NULL;
5316 }
5317
5318
5319 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5320 PyObject *resultobj = 0;
5321 wxString result;
5322
5323 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = wxGetHostName();
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 #if wxUSE_UNICODE
5332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5333 #else
5334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5335 #endif
5336 }
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344 PyObject *resultobj = 0;
5345 wxString result;
5346
5347 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = wxGetFullHostName();
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 #if wxUSE_UNICODE
5356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5357 #else
5358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5359 #endif
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *resultobj = 0;
5369 wxString result;
5370
5371 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = wxGetUserId();
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 {
5379 #if wxUSE_UNICODE
5380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5381 #else
5382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5383 #endif
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5392 PyObject *resultobj = 0;
5393 wxString result;
5394
5395 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 result = wxGetUserName();
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 #if wxUSE_UNICODE
5404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5405 #else
5406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5407 #endif
5408 }
5409 return resultobj;
5410 fail:
5411 return NULL;
5412 }
5413
5414
5415 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5416 PyObject *resultobj = 0;
5417 wxString result;
5418
5419 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5420 {
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = wxGetHomeDir();
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 {
5427 #if wxUSE_UNICODE
5428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5429 #else
5430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5431 #endif
5432 }
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 wxString const &arg1_defvalue = wxPyEmptyString ;
5442 wxString *arg1 = (wxString *) &arg1_defvalue ;
5443 wxString result;
5444 bool temp1 = false ;
5445 PyObject * obj0 = 0 ;
5446 char * kwnames[] = {
5447 (char *) "user", NULL
5448 };
5449
5450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5451 if (obj0) {
5452 {
5453 arg1 = wxString_in_helper(obj0);
5454 if (arg1 == NULL) SWIG_fail;
5455 temp1 = true;
5456 }
5457 }
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 result = wxGetUserHome((wxString const &)*arg1);
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 {
5465 #if wxUSE_UNICODE
5466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5467 #else
5468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5469 #endif
5470 }
5471 {
5472 if (temp1)
5473 delete arg1;
5474 }
5475 return resultobj;
5476 fail:
5477 {
5478 if (temp1)
5479 delete arg1;
5480 }
5481 return NULL;
5482 }
5483
5484
5485 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5486 PyObject *resultobj = 0;
5487 unsigned long result;
5488
5489 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (unsigned long)wxGetProcessId();
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
5503 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5504 PyObject *resultobj = 0;
5505
5506 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5507 {
5508 PyThreadState* __tstate = wxPyBeginAllowThreads();
5509 wxTrap();
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 resultobj = SWIG_Py_Void();
5514 return resultobj;
5515 fail:
5516 return NULL;
5517 }
5518
5519
5520 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5521 PyObject *resultobj = 0;
5522 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5523 wxString *arg1 = (wxString *) &arg1_defvalue ;
5524 wxString const &arg2_defvalue = wxPyEmptyString ;
5525 wxString *arg2 = (wxString *) &arg2_defvalue ;
5526 wxString const &arg3_defvalue = wxPyEmptyString ;
5527 wxString *arg3 = (wxString *) &arg3_defvalue ;
5528 wxString const &arg4_defvalue = wxPyEmptyString ;
5529 wxString *arg4 = (wxString *) &arg4_defvalue ;
5530 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5531 wxString *arg5 = (wxString *) &arg5_defvalue ;
5532 int arg6 = (int) 0 ;
5533 wxWindow *arg7 = (wxWindow *) NULL ;
5534 int arg8 = (int) -1 ;
5535 int arg9 = (int) -1 ;
5536 wxString result;
5537 bool temp1 = false ;
5538 bool temp2 = false ;
5539 bool temp3 = false ;
5540 bool temp4 = false ;
5541 bool temp5 = false ;
5542 int val6 ;
5543 int ecode6 = 0 ;
5544 void *argp7 = 0 ;
5545 int res7 = 0 ;
5546 int val8 ;
5547 int ecode8 = 0 ;
5548 int val9 ;
5549 int ecode9 = 0 ;
5550 PyObject * obj0 = 0 ;
5551 PyObject * obj1 = 0 ;
5552 PyObject * obj2 = 0 ;
5553 PyObject * obj3 = 0 ;
5554 PyObject * obj4 = 0 ;
5555 PyObject * obj5 = 0 ;
5556 PyObject * obj6 = 0 ;
5557 PyObject * obj7 = 0 ;
5558 PyObject * obj8 = 0 ;
5559 char * kwnames[] = {
5560 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5561 };
5562
5563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5564 if (obj0) {
5565 {
5566 arg1 = wxString_in_helper(obj0);
5567 if (arg1 == NULL) SWIG_fail;
5568 temp1 = true;
5569 }
5570 }
5571 if (obj1) {
5572 {
5573 arg2 = wxString_in_helper(obj1);
5574 if (arg2 == NULL) SWIG_fail;
5575 temp2 = true;
5576 }
5577 }
5578 if (obj2) {
5579 {
5580 arg3 = wxString_in_helper(obj2);
5581 if (arg3 == NULL) SWIG_fail;
5582 temp3 = true;
5583 }
5584 }
5585 if (obj3) {
5586 {
5587 arg4 = wxString_in_helper(obj3);
5588 if (arg4 == NULL) SWIG_fail;
5589 temp4 = true;
5590 }
5591 }
5592 if (obj4) {
5593 {
5594 arg5 = wxString_in_helper(obj4);
5595 if (arg5 == NULL) SWIG_fail;
5596 temp5 = true;
5597 }
5598 }
5599 if (obj5) {
5600 ecode6 = SWIG_AsVal_int(obj5, &val6);
5601 if (!SWIG_IsOK(ecode6)) {
5602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5603 }
5604 arg6 = static_cast< int >(val6);
5605 }
5606 if (obj6) {
5607 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5608 if (!SWIG_IsOK(res7)) {
5609 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5610 }
5611 arg7 = reinterpret_cast< wxWindow * >(argp7);
5612 }
5613 if (obj7) {
5614 ecode8 = SWIG_AsVal_int(obj7, &val8);
5615 if (!SWIG_IsOK(ecode8)) {
5616 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5617 }
5618 arg8 = static_cast< int >(val8);
5619 }
5620 if (obj8) {
5621 ecode9 = SWIG_AsVal_int(obj8, &val9);
5622 if (!SWIG_IsOK(ecode9)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5624 }
5625 arg9 = static_cast< int >(val9);
5626 }
5627 {
5628 if (!wxPyCheckForApp()) SWIG_fail;
5629 PyThreadState* __tstate = wxPyBeginAllowThreads();
5630 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 {
5635 #if wxUSE_UNICODE
5636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5637 #else
5638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5639 #endif
5640 }
5641 {
5642 if (temp1)
5643 delete arg1;
5644 }
5645 {
5646 if (temp2)
5647 delete arg2;
5648 }
5649 {
5650 if (temp3)
5651 delete arg3;
5652 }
5653 {
5654 if (temp4)
5655 delete arg4;
5656 }
5657 {
5658 if (temp5)
5659 delete arg5;
5660 }
5661 return resultobj;
5662 fail:
5663 {
5664 if (temp1)
5665 delete arg1;
5666 }
5667 {
5668 if (temp2)
5669 delete arg2;
5670 }
5671 {
5672 if (temp3)
5673 delete arg3;
5674 }
5675 {
5676 if (temp4)
5677 delete arg4;
5678 }
5679 {
5680 if (temp5)
5681 delete arg5;
5682 }
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj = 0;
5689 wxString *arg1 = 0 ;
5690 wxString *arg2 = 0 ;
5691 wxString const &arg3_defvalue = wxPyEmptyString ;
5692 wxString *arg3 = (wxString *) &arg3_defvalue ;
5693 wxWindow *arg4 = (wxWindow *) NULL ;
5694 wxString result;
5695 bool temp1 = false ;
5696 bool temp2 = false ;
5697 bool temp3 = false ;
5698 void *argp4 = 0 ;
5699 int res4 = 0 ;
5700 PyObject * obj0 = 0 ;
5701 PyObject * obj1 = 0 ;
5702 PyObject * obj2 = 0 ;
5703 PyObject * obj3 = 0 ;
5704 char * kwnames[] = {
5705 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5706 };
5707
5708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5709 {
5710 arg1 = wxString_in_helper(obj0);
5711 if (arg1 == NULL) SWIG_fail;
5712 temp1 = true;
5713 }
5714 {
5715 arg2 = wxString_in_helper(obj1);
5716 if (arg2 == NULL) SWIG_fail;
5717 temp2 = true;
5718 }
5719 if (obj2) {
5720 {
5721 arg3 = wxString_in_helper(obj2);
5722 if (arg3 == NULL) SWIG_fail;
5723 temp3 = true;
5724 }
5725 }
5726 if (obj3) {
5727 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5728 if (!SWIG_IsOK(res4)) {
5729 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5730 }
5731 arg4 = reinterpret_cast< wxWindow * >(argp4);
5732 }
5733 {
5734 if (!wxPyCheckForApp()) SWIG_fail;
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 {
5741 #if wxUSE_UNICODE
5742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5743 #else
5744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5745 #endif
5746 }
5747 {
5748 if (temp1)
5749 delete arg1;
5750 }
5751 {
5752 if (temp2)
5753 delete arg2;
5754 }
5755 {
5756 if (temp3)
5757 delete arg3;
5758 }
5759 return resultobj;
5760 fail:
5761 {
5762 if (temp1)
5763 delete arg1;
5764 }
5765 {
5766 if (temp2)
5767 delete arg2;
5768 }
5769 {
5770 if (temp3)
5771 delete arg3;
5772 }
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj = 0;
5779 wxString *arg1 = 0 ;
5780 wxString *arg2 = 0 ;
5781 wxString const &arg3_defvalue = wxPyEmptyString ;
5782 wxString *arg3 = (wxString *) &arg3_defvalue ;
5783 wxWindow *arg4 = (wxWindow *) NULL ;
5784 wxString result;
5785 bool temp1 = false ;
5786 bool temp2 = false ;
5787 bool temp3 = false ;
5788 void *argp4 = 0 ;
5789 int res4 = 0 ;
5790 PyObject * obj0 = 0 ;
5791 PyObject * obj1 = 0 ;
5792 PyObject * obj2 = 0 ;
5793 PyObject * obj3 = 0 ;
5794 char * kwnames[] = {
5795 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5796 };
5797
5798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5799 {
5800 arg1 = wxString_in_helper(obj0);
5801 if (arg1 == NULL) SWIG_fail;
5802 temp1 = true;
5803 }
5804 {
5805 arg2 = wxString_in_helper(obj1);
5806 if (arg2 == NULL) SWIG_fail;
5807 temp2 = true;
5808 }
5809 if (obj2) {
5810 {
5811 arg3 = wxString_in_helper(obj2);
5812 if (arg3 == NULL) SWIG_fail;
5813 temp3 = true;
5814 }
5815 }
5816 if (obj3) {
5817 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5818 if (!SWIG_IsOK(res4)) {
5819 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5820 }
5821 arg4 = reinterpret_cast< wxWindow * >(argp4);
5822 }
5823 {
5824 if (!wxPyCheckForApp()) SWIG_fail;
5825 PyThreadState* __tstate = wxPyBeginAllowThreads();
5826 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 {
5831 #if wxUSE_UNICODE
5832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5833 #else
5834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5835 #endif
5836 }
5837 {
5838 if (temp1)
5839 delete arg1;
5840 }
5841 {
5842 if (temp2)
5843 delete arg2;
5844 }
5845 {
5846 if (temp3)
5847 delete arg3;
5848 }
5849 return resultobj;
5850 fail:
5851 {
5852 if (temp1)
5853 delete arg1;
5854 }
5855 {
5856 if (temp2)
5857 delete arg2;
5858 }
5859 {
5860 if (temp3)
5861 delete arg3;
5862 }
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5868 PyObject *resultobj = 0;
5869 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5870 wxString *arg1 = (wxString *) &arg1_defvalue ;
5871 wxString const &arg2_defvalue = wxPyEmptyString ;
5872 wxString *arg2 = (wxString *) &arg2_defvalue ;
5873 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5874 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5875 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5876 wxWindow *arg5 = (wxWindow *) NULL ;
5877 wxString result;
5878 bool temp1 = false ;
5879 bool temp2 = false ;
5880 long val3 ;
5881 int ecode3 = 0 ;
5882 wxPoint temp4 ;
5883 void *argp5 = 0 ;
5884 int res5 = 0 ;
5885 PyObject * obj0 = 0 ;
5886 PyObject * obj1 = 0 ;
5887 PyObject * obj2 = 0 ;
5888 PyObject * obj3 = 0 ;
5889 PyObject * obj4 = 0 ;
5890 char * kwnames[] = {
5891 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5892 };
5893
5894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5895 if (obj0) {
5896 {
5897 arg1 = wxString_in_helper(obj0);
5898 if (arg1 == NULL) SWIG_fail;
5899 temp1 = true;
5900 }
5901 }
5902 if (obj1) {
5903 {
5904 arg2 = wxString_in_helper(obj1);
5905 if (arg2 == NULL) SWIG_fail;
5906 temp2 = true;
5907 }
5908 }
5909 if (obj2) {
5910 ecode3 = SWIG_AsVal_long(obj2, &val3);
5911 if (!SWIG_IsOK(ecode3)) {
5912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5913 }
5914 arg3 = static_cast< long >(val3);
5915 }
5916 if (obj3) {
5917 {
5918 arg4 = &temp4;
5919 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5920 }
5921 }
5922 if (obj4) {
5923 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5924 if (!SWIG_IsOK(res5)) {
5925 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5926 }
5927 arg5 = reinterpret_cast< wxWindow * >(argp5);
5928 }
5929 {
5930 if (!wxPyCheckForApp()) SWIG_fail;
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 #if wxUSE_UNICODE
5938 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5939 #else
5940 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5941 #endif
5942 }
5943 {
5944 if (temp1)
5945 delete arg1;
5946 }
5947 {
5948 if (temp2)
5949 delete arg2;
5950 }
5951 return resultobj;
5952 fail:
5953 {
5954 if (temp1)
5955 delete arg1;
5956 }
5957 {
5958 if (temp2)
5959 delete arg2;
5960 }
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj = 0;
5967 wxString *arg1 = 0 ;
5968 wxString const &arg2_defvalue = wxPyEmptyString ;
5969 wxString *arg2 = (wxString *) &arg2_defvalue ;
5970 wxString const &arg3_defvalue = wxPyEmptyString ;
5971 wxString *arg3 = (wxString *) &arg3_defvalue ;
5972 wxWindow *arg4 = (wxWindow *) NULL ;
5973 int arg5 = (int) -1 ;
5974 int arg6 = (int) -1 ;
5975 bool arg7 = (bool) true ;
5976 wxString result;
5977 bool temp1 = false ;
5978 bool temp2 = false ;
5979 bool temp3 = false ;
5980 void *argp4 = 0 ;
5981 int res4 = 0 ;
5982 int val5 ;
5983 int ecode5 = 0 ;
5984 int val6 ;
5985 int ecode6 = 0 ;
5986 bool val7 ;
5987 int ecode7 = 0 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 PyObject * obj2 = 0 ;
5991 PyObject * obj3 = 0 ;
5992 PyObject * obj4 = 0 ;
5993 PyObject * obj5 = 0 ;
5994 PyObject * obj6 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6000 {
6001 arg1 = wxString_in_helper(obj0);
6002 if (arg1 == NULL) SWIG_fail;
6003 temp1 = true;
6004 }
6005 if (obj1) {
6006 {
6007 arg2 = wxString_in_helper(obj1);
6008 if (arg2 == NULL) SWIG_fail;
6009 temp2 = true;
6010 }
6011 }
6012 if (obj2) {
6013 {
6014 arg3 = wxString_in_helper(obj2);
6015 if (arg3 == NULL) SWIG_fail;
6016 temp3 = true;
6017 }
6018 }
6019 if (obj3) {
6020 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6021 if (!SWIG_IsOK(res4)) {
6022 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6023 }
6024 arg4 = reinterpret_cast< wxWindow * >(argp4);
6025 }
6026 if (obj4) {
6027 ecode5 = SWIG_AsVal_int(obj4, &val5);
6028 if (!SWIG_IsOK(ecode5)) {
6029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6030 }
6031 arg5 = static_cast< int >(val5);
6032 }
6033 if (obj5) {
6034 ecode6 = SWIG_AsVal_int(obj5, &val6);
6035 if (!SWIG_IsOK(ecode6)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6037 }
6038 arg6 = static_cast< int >(val6);
6039 }
6040 if (obj6) {
6041 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6042 if (!SWIG_IsOK(ecode7)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6044 }
6045 arg7 = static_cast< bool >(val7);
6046 }
6047 {
6048 if (!wxPyCheckForApp()) SWIG_fail;
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 #if wxUSE_UNICODE
6056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6057 #else
6058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6059 #endif
6060 }
6061 {
6062 if (temp1)
6063 delete arg1;
6064 }
6065 {
6066 if (temp2)
6067 delete arg2;
6068 }
6069 {
6070 if (temp3)
6071 delete arg3;
6072 }
6073 return resultobj;
6074 fail:
6075 {
6076 if (temp1)
6077 delete arg1;
6078 }
6079 {
6080 if (temp2)
6081 delete arg2;
6082 }
6083 {
6084 if (temp3)
6085 delete arg3;
6086 }
6087 return NULL;
6088 }
6089
6090
6091 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6092 PyObject *resultobj = 0;
6093 wxString *arg1 = 0 ;
6094 wxString const &arg2_defvalue = wxPyEmptyString ;
6095 wxString *arg2 = (wxString *) &arg2_defvalue ;
6096 wxString const &arg3_defvalue = wxPyEmptyString ;
6097 wxString *arg3 = (wxString *) &arg3_defvalue ;
6098 wxWindow *arg4 = (wxWindow *) NULL ;
6099 wxString result;
6100 bool temp1 = false ;
6101 bool temp2 = false ;
6102 bool temp3 = false ;
6103 void *argp4 = 0 ;
6104 int res4 = 0 ;
6105 PyObject * obj0 = 0 ;
6106 PyObject * obj1 = 0 ;
6107 PyObject * obj2 = 0 ;
6108 PyObject * obj3 = 0 ;
6109 char * kwnames[] = {
6110 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6111 };
6112
6113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6114 {
6115 arg1 = wxString_in_helper(obj0);
6116 if (arg1 == NULL) SWIG_fail;
6117 temp1 = true;
6118 }
6119 if (obj1) {
6120 {
6121 arg2 = wxString_in_helper(obj1);
6122 if (arg2 == NULL) SWIG_fail;
6123 temp2 = true;
6124 }
6125 }
6126 if (obj2) {
6127 {
6128 arg3 = wxString_in_helper(obj2);
6129 if (arg3 == NULL) SWIG_fail;
6130 temp3 = true;
6131 }
6132 }
6133 if (obj3) {
6134 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6135 if (!SWIG_IsOK(res4)) {
6136 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6137 }
6138 arg4 = reinterpret_cast< wxWindow * >(argp4);
6139 }
6140 {
6141 if (!wxPyCheckForApp()) SWIG_fail;
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 {
6148 #if wxUSE_UNICODE
6149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6150 #else
6151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6152 #endif
6153 }
6154 {
6155 if (temp1)
6156 delete arg1;
6157 }
6158 {
6159 if (temp2)
6160 delete arg2;
6161 }
6162 {
6163 if (temp3)
6164 delete arg3;
6165 }
6166 return resultobj;
6167 fail:
6168 {
6169 if (temp1)
6170 delete arg1;
6171 }
6172 {
6173 if (temp2)
6174 delete arg2;
6175 }
6176 {
6177 if (temp3)
6178 delete arg3;
6179 }
6180 return NULL;
6181 }
6182
6183
6184 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj = 0;
6186 wxString *arg1 = 0 ;
6187 wxString *arg2 = 0 ;
6188 int arg3 ;
6189 wxString *arg4 = (wxString *) 0 ;
6190 wxWindow *arg5 = (wxWindow *) NULL ;
6191 int arg6 = (int) -1 ;
6192 int arg7 = (int) -1 ;
6193 bool arg8 = (bool) true ;
6194 int arg9 = (int) 150 ;
6195 int arg10 = (int) 200 ;
6196 wxString result;
6197 bool temp1 = false ;
6198 bool temp2 = false ;
6199 void *argp5 = 0 ;
6200 int res5 = 0 ;
6201 int val6 ;
6202 int ecode6 = 0 ;
6203 int val7 ;
6204 int ecode7 = 0 ;
6205 bool val8 ;
6206 int ecode8 = 0 ;
6207 int val9 ;
6208 int ecode9 = 0 ;
6209 int val10 ;
6210 int ecode10 = 0 ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 PyObject * obj2 = 0 ;
6214 PyObject * obj3 = 0 ;
6215 PyObject * obj4 = 0 ;
6216 PyObject * obj5 = 0 ;
6217 PyObject * obj6 = 0 ;
6218 PyObject * obj7 = 0 ;
6219 PyObject * obj8 = 0 ;
6220 char * kwnames[] = {
6221 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6222 };
6223
6224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6225 {
6226 arg1 = wxString_in_helper(obj0);
6227 if (arg1 == NULL) SWIG_fail;
6228 temp1 = true;
6229 }
6230 {
6231 arg2 = wxString_in_helper(obj1);
6232 if (arg2 == NULL) SWIG_fail;
6233 temp2 = true;
6234 }
6235 {
6236 arg3 = PyList_Size(obj2);
6237 arg4 = wxString_LIST_helper(obj2);
6238 if (arg4 == NULL) SWIG_fail;
6239 }
6240 if (obj3) {
6241 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6242 if (!SWIG_IsOK(res5)) {
6243 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6244 }
6245 arg5 = reinterpret_cast< wxWindow * >(argp5);
6246 }
6247 if (obj4) {
6248 ecode6 = SWIG_AsVal_int(obj4, &val6);
6249 if (!SWIG_IsOK(ecode6)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6251 }
6252 arg6 = static_cast< int >(val6);
6253 }
6254 if (obj5) {
6255 ecode7 = SWIG_AsVal_int(obj5, &val7);
6256 if (!SWIG_IsOK(ecode7)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6258 }
6259 arg7 = static_cast< int >(val7);
6260 }
6261 if (obj6) {
6262 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6263 if (!SWIG_IsOK(ecode8)) {
6264 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6265 }
6266 arg8 = static_cast< bool >(val8);
6267 }
6268 if (obj7) {
6269 ecode9 = SWIG_AsVal_int(obj7, &val9);
6270 if (!SWIG_IsOK(ecode9)) {
6271 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6272 }
6273 arg9 = static_cast< int >(val9);
6274 }
6275 if (obj8) {
6276 ecode10 = SWIG_AsVal_int(obj8, &val10);
6277 if (!SWIG_IsOK(ecode10)) {
6278 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6279 }
6280 arg10 = static_cast< int >(val10);
6281 }
6282 {
6283 if (!wxPyCheckForApp()) SWIG_fail;
6284 PyThreadState* __tstate = wxPyBeginAllowThreads();
6285 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6286 wxPyEndAllowThreads(__tstate);
6287 if (PyErr_Occurred()) SWIG_fail;
6288 }
6289 {
6290 #if wxUSE_UNICODE
6291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6292 #else
6293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6294 #endif
6295 }
6296 {
6297 if (temp1)
6298 delete arg1;
6299 }
6300 {
6301 if (temp2)
6302 delete arg2;
6303 }
6304 {
6305 if (arg4) delete [] arg4;
6306 }
6307 return resultobj;
6308 fail:
6309 {
6310 if (temp1)
6311 delete arg1;
6312 }
6313 {
6314 if (temp2)
6315 delete arg2;
6316 }
6317 {
6318 if (arg4) delete [] arg4;
6319 }
6320 return NULL;
6321 }
6322
6323
6324 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6325 PyObject *resultobj = 0;
6326 wxString *arg1 = 0 ;
6327 wxString *arg2 = 0 ;
6328 int arg3 ;
6329 wxString *arg4 = (wxString *) 0 ;
6330 wxWindow *arg5 = (wxWindow *) NULL ;
6331 int arg6 = (int) -1 ;
6332 int arg7 = (int) -1 ;
6333 bool arg8 = (bool) true ;
6334 int arg9 = (int) 150 ;
6335 int arg10 = (int) 200 ;
6336 int result;
6337 bool temp1 = false ;
6338 bool temp2 = false ;
6339 void *argp5 = 0 ;
6340 int res5 = 0 ;
6341 int val6 ;
6342 int ecode6 = 0 ;
6343 int val7 ;
6344 int ecode7 = 0 ;
6345 bool val8 ;
6346 int ecode8 = 0 ;
6347 int val9 ;
6348 int ecode9 = 0 ;
6349 int val10 ;
6350 int ecode10 = 0 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 PyObject * obj2 = 0 ;
6354 PyObject * obj3 = 0 ;
6355 PyObject * obj4 = 0 ;
6356 PyObject * obj5 = 0 ;
6357 PyObject * obj6 = 0 ;
6358 PyObject * obj7 = 0 ;
6359 PyObject * obj8 = 0 ;
6360 char * kwnames[] = {
6361 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6362 };
6363
6364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6365 {
6366 arg1 = wxString_in_helper(obj0);
6367 if (arg1 == NULL) SWIG_fail;
6368 temp1 = true;
6369 }
6370 {
6371 arg2 = wxString_in_helper(obj1);
6372 if (arg2 == NULL) SWIG_fail;
6373 temp2 = true;
6374 }
6375 {
6376 arg3 = PyList_Size(obj2);
6377 arg4 = wxString_LIST_helper(obj2);
6378 if (arg4 == NULL) SWIG_fail;
6379 }
6380 if (obj3) {
6381 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6382 if (!SWIG_IsOK(res5)) {
6383 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6384 }
6385 arg5 = reinterpret_cast< wxWindow * >(argp5);
6386 }
6387 if (obj4) {
6388 ecode6 = SWIG_AsVal_int(obj4, &val6);
6389 if (!SWIG_IsOK(ecode6)) {
6390 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6391 }
6392 arg6 = static_cast< int >(val6);
6393 }
6394 if (obj5) {
6395 ecode7 = SWIG_AsVal_int(obj5, &val7);
6396 if (!SWIG_IsOK(ecode7)) {
6397 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6398 }
6399 arg7 = static_cast< int >(val7);
6400 }
6401 if (obj6) {
6402 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6403 if (!SWIG_IsOK(ecode8)) {
6404 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6405 }
6406 arg8 = static_cast< bool >(val8);
6407 }
6408 if (obj7) {
6409 ecode9 = SWIG_AsVal_int(obj7, &val9);
6410 if (!SWIG_IsOK(ecode9)) {
6411 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6412 }
6413 arg9 = static_cast< int >(val9);
6414 }
6415 if (obj8) {
6416 ecode10 = SWIG_AsVal_int(obj8, &val10);
6417 if (!SWIG_IsOK(ecode10)) {
6418 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6419 }
6420 arg10 = static_cast< int >(val10);
6421 }
6422 {
6423 if (!wxPyCheckForApp()) SWIG_fail;
6424 PyThreadState* __tstate = wxPyBeginAllowThreads();
6425 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = SWIG_From_int(static_cast< int >(result));
6430 {
6431 if (temp1)
6432 delete arg1;
6433 }
6434 {
6435 if (temp2)
6436 delete arg2;
6437 }
6438 {
6439 if (arg4) delete [] arg4;
6440 }
6441 return resultobj;
6442 fail:
6443 {
6444 if (temp1)
6445 delete arg1;
6446 }
6447 {
6448 if (temp2)
6449 delete arg2;
6450 }
6451 {
6452 if (arg4) delete [] arg4;
6453 }
6454 return NULL;
6455 }
6456
6457
6458 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj = 0;
6460 wxString *arg1 = 0 ;
6461 wxString const &arg2_defvalue = wxPyEmptyString ;
6462 wxString *arg2 = (wxString *) &arg2_defvalue ;
6463 int arg3 = (int) wxOK|wxCENTRE ;
6464 wxWindow *arg4 = (wxWindow *) NULL ;
6465 int arg5 = (int) -1 ;
6466 int arg6 = (int) -1 ;
6467 int result;
6468 bool temp1 = false ;
6469 bool temp2 = false ;
6470 int val3 ;
6471 int ecode3 = 0 ;
6472 void *argp4 = 0 ;
6473 int res4 = 0 ;
6474 int val5 ;
6475 int ecode5 = 0 ;
6476 int val6 ;
6477 int ecode6 = 0 ;
6478 PyObject * obj0 = 0 ;
6479 PyObject * obj1 = 0 ;
6480 PyObject * obj2 = 0 ;
6481 PyObject * obj3 = 0 ;
6482 PyObject * obj4 = 0 ;
6483 PyObject * obj5 = 0 ;
6484 char * kwnames[] = {
6485 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6486 };
6487
6488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6489 {
6490 arg1 = wxString_in_helper(obj0);
6491 if (arg1 == NULL) SWIG_fail;
6492 temp1 = true;
6493 }
6494 if (obj1) {
6495 {
6496 arg2 = wxString_in_helper(obj1);
6497 if (arg2 == NULL) SWIG_fail;
6498 temp2 = true;
6499 }
6500 }
6501 if (obj2) {
6502 ecode3 = SWIG_AsVal_int(obj2, &val3);
6503 if (!SWIG_IsOK(ecode3)) {
6504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6505 }
6506 arg3 = static_cast< int >(val3);
6507 }
6508 if (obj3) {
6509 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6510 if (!SWIG_IsOK(res4)) {
6511 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6512 }
6513 arg4 = reinterpret_cast< wxWindow * >(argp4);
6514 }
6515 if (obj4) {
6516 ecode5 = SWIG_AsVal_int(obj4, &val5);
6517 if (!SWIG_IsOK(ecode5)) {
6518 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6519 }
6520 arg5 = static_cast< int >(val5);
6521 }
6522 if (obj5) {
6523 ecode6 = SWIG_AsVal_int(obj5, &val6);
6524 if (!SWIG_IsOK(ecode6)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6526 }
6527 arg6 = static_cast< int >(val6);
6528 }
6529 {
6530 if (!wxPyCheckForApp()) SWIG_fail;
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 resultobj = SWIG_From_int(static_cast< int >(result));
6537 {
6538 if (temp1)
6539 delete arg1;
6540 }
6541 {
6542 if (temp2)
6543 delete arg2;
6544 }
6545 return resultobj;
6546 fail:
6547 {
6548 if (temp1)
6549 delete arg1;
6550 }
6551 {
6552 if (temp2)
6553 delete arg2;
6554 }
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6560 PyObject *resultobj = 0;
6561 bool result;
6562
6563 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6564 {
6565 if (!wxPyCheckForApp()) SWIG_fail;
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 result = (bool)wxColourDisplay();
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 {
6572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6573 }
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6581 PyObject *resultobj = 0;
6582 int result;
6583
6584 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6585 {
6586 if (!wxPyCheckForApp()) SWIG_fail;
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 result = (int)wxDisplayDepth();
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6600 PyObject *resultobj = 0;
6601 int result;
6602
6603 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6604 {
6605 if (!wxPyCheckForApp()) SWIG_fail;
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = (int)wxGetDisplayDepth();
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 resultobj = SWIG_From_int(static_cast< int >(result));
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6619 PyObject *resultobj = 0;
6620 int *arg1 = (int *) 0 ;
6621 int *arg2 = (int *) 0 ;
6622 int temp1 ;
6623 int res1 = SWIG_TMPOBJ ;
6624 int temp2 ;
6625 int res2 = SWIG_TMPOBJ ;
6626
6627 arg1 = &temp1;
6628 arg2 = &temp2;
6629 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6630 {
6631 if (!wxPyCheckForApp()) SWIG_fail;
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 wxDisplaySize(arg1,arg2);
6634 wxPyEndAllowThreads(__tstate);
6635 if (PyErr_Occurred()) SWIG_fail;
6636 }
6637 resultobj = SWIG_Py_Void();
6638 if (SWIG_IsTmpObj(res1)) {
6639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6640 } else {
6641 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6643 }
6644 if (SWIG_IsTmpObj(res2)) {
6645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6646 } else {
6647 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6649 }
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6657 PyObject *resultobj = 0;
6658 wxSize result;
6659
6660 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6661 {
6662 if (!wxPyCheckForApp()) SWIG_fail;
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 result = wxGetDisplaySize();
6665 wxPyEndAllowThreads(__tstate);
6666 if (PyErr_Occurred()) SWIG_fail;
6667 }
6668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6669 return resultobj;
6670 fail:
6671 return NULL;
6672 }
6673
6674
6675 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6676 PyObject *resultobj = 0;
6677 int *arg1 = (int *) 0 ;
6678 int *arg2 = (int *) 0 ;
6679 int temp1 ;
6680 int res1 = SWIG_TMPOBJ ;
6681 int temp2 ;
6682 int res2 = SWIG_TMPOBJ ;
6683
6684 arg1 = &temp1;
6685 arg2 = &temp2;
6686 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6687 {
6688 if (!wxPyCheckForApp()) SWIG_fail;
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 wxDisplaySizeMM(arg1,arg2);
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 resultobj = SWIG_Py_Void();
6695 if (SWIG_IsTmpObj(res1)) {
6696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6697 } else {
6698 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6700 }
6701 if (SWIG_IsTmpObj(res2)) {
6702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6703 } else {
6704 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6706 }
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6714 PyObject *resultobj = 0;
6715 wxSize result;
6716
6717 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6718 {
6719 if (!wxPyCheckForApp()) SWIG_fail;
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 result = wxGetDisplaySizeMM();
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6733 PyObject *resultobj = 0;
6734 int *arg1 = (int *) 0 ;
6735 int *arg2 = (int *) 0 ;
6736 int *arg3 = (int *) 0 ;
6737 int *arg4 = (int *) 0 ;
6738 int temp1 ;
6739 int res1 = SWIG_TMPOBJ ;
6740 int temp2 ;
6741 int res2 = SWIG_TMPOBJ ;
6742 int temp3 ;
6743 int res3 = SWIG_TMPOBJ ;
6744 int temp4 ;
6745 int res4 = SWIG_TMPOBJ ;
6746
6747 arg1 = &temp1;
6748 arg2 = &temp2;
6749 arg3 = &temp3;
6750 arg4 = &temp4;
6751 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6752 {
6753 if (!wxPyCheckForApp()) SWIG_fail;
6754 PyThreadState* __tstate = wxPyBeginAllowThreads();
6755 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 resultobj = SWIG_Py_Void();
6760 if (SWIG_IsTmpObj(res1)) {
6761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6762 } else {
6763 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6765 }
6766 if (SWIG_IsTmpObj(res2)) {
6767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6768 } else {
6769 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6771 }
6772 if (SWIG_IsTmpObj(res3)) {
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6774 } else {
6775 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6777 }
6778 if (SWIG_IsTmpObj(res4)) {
6779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6780 } else {
6781 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6783 }
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6791 PyObject *resultobj = 0;
6792 wxRect result;
6793
6794 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6795 {
6796 if (!wxPyCheckForApp()) SWIG_fail;
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 result = wxGetClientDisplayRect();
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxCursor *arg1 = 0 ;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 PyObject * obj0 = 0 ;
6815 char * kwnames[] = {
6816 (char *) "cursor", NULL
6817 };
6818
6819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6820 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6821 if (!SWIG_IsOK(res1)) {
6822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6823 }
6824 if (!argp1) {
6825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6826 }
6827 arg1 = reinterpret_cast< wxCursor * >(argp1);
6828 {
6829 if (!wxPyCheckForApp()) SWIG_fail;
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 wxSetCursor(*arg1);
6832 wxPyEndAllowThreads(__tstate);
6833 if (PyErr_Occurred()) SWIG_fail;
6834 }
6835 resultobj = SWIG_Py_Void();
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 PyObject *resultobj = 0;
6844 void *result = 0 ;
6845
6846 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6847 {
6848 if (!wxPyCheckForApp()) SWIG_fail;
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (void *)wxGetXDisplay();
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj = 0;
6863 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6864 void *argp1 = 0 ;
6865 int res1 = 0 ;
6866 PyObject * obj0 = 0 ;
6867 char * kwnames[] = {
6868 (char *) "cursor", NULL
6869 };
6870
6871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6872 if (obj0) {
6873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6874 if (!SWIG_IsOK(res1)) {
6875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6876 }
6877 arg1 = reinterpret_cast< wxCursor * >(argp1);
6878 }
6879 {
6880 if (!wxPyCheckForApp()) SWIG_fail;
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 wxBeginBusyCursor(arg1);
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 resultobj = SWIG_Py_Void();
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894 PyObject *resultobj = 0;
6895 wxPoint result;
6896
6897 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6898 {
6899 if (!wxPyCheckForApp()) SWIG_fail;
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = wxGetMousePosition();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxWindow *result = 0 ;
6915
6916 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6917 {
6918 if (!wxPyCheckForApp()) SWIG_fail;
6919 PyThreadState* __tstate = wxPyBeginAllowThreads();
6920 result = (wxWindow *)FindWindowAtPointer();
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 {
6925 resultobj = wxPyMake_wxObject(result, 0);
6926 }
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6934 PyObject *resultobj = 0;
6935 wxWindow *result = 0 ;
6936
6937 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6938 {
6939 if (!wxPyCheckForApp()) SWIG_fail;
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = (wxWindow *)wxGetActiveWindow();
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 {
6946 resultobj = wxPyMake_wxObject(result, 0);
6947 }
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj = 0;
6956 wxPoint *arg1 = 0 ;
6957 wxWindow *result = 0 ;
6958 wxPoint temp1 ;
6959 PyObject * obj0 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "pt", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6965 {
6966 arg1 = &temp1;
6967 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6968 }
6969 {
6970 if (!wxPyCheckForApp()) SWIG_fail;
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 {
6977 resultobj = wxPyMake_wxObject(result, 0);
6978 }
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj = 0;
6987 wxPoint *arg1 = 0 ;
6988 wxWindow *result = 0 ;
6989 wxPoint temp1 ;
6990 PyObject * obj0 = 0 ;
6991 char * kwnames[] = {
6992 (char *) "pt", NULL
6993 };
6994
6995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6996 {
6997 arg1 = &temp1;
6998 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6999 }
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 {
7008 resultobj = wxPyMake_wxObject(result, 0);
7009 }
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxWindow *arg1 = (wxWindow *) 0 ;
7019 wxWindow *result = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 PyObject * obj0 = 0 ;
7023 char * kwnames[] = {
7024 (char *) "win", NULL
7025 };
7026
7027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7029 if (!SWIG_IsOK(res1)) {
7030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7031 }
7032 arg1 = reinterpret_cast< wxWindow * >(argp1);
7033 {
7034 if (!wxPyCheckForApp()) SWIG_fail;
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 result = (wxWindow *)wxGetTopLevelParent(arg1);
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 {
7041 resultobj = wxPyMake_wxObject(result, 0);
7042 }
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7050 PyObject *resultobj = 0;
7051 wxString *arg1 = 0 ;
7052 bool result;
7053 bool temp1 = false ;
7054 PyObject * obj0 = 0 ;
7055 char * kwnames[] = {
7056 (char *) "url", NULL
7057 };
7058
7059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7060 {
7061 arg1 = wxString_in_helper(obj0);
7062 if (arg1 == NULL) SWIG_fail;
7063 temp1 = true;
7064 }
7065 {
7066 PyThreadState* __tstate = wxPyBeginAllowThreads();
7067 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7068 wxPyEndAllowThreads(__tstate);
7069 if (PyErr_Occurred()) SWIG_fail;
7070 }
7071 {
7072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7073 }
7074 {
7075 if (temp1)
7076 delete arg1;
7077 }
7078 return resultobj;
7079 fail:
7080 {
7081 if (temp1)
7082 delete arg1;
7083 }
7084 return NULL;
7085 }
7086
7087
7088 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj = 0;
7090 wxKeyCode arg1 ;
7091 bool result;
7092 int val1 ;
7093 int ecode1 = 0 ;
7094 PyObject * obj0 = 0 ;
7095 char * kwnames[] = {
7096 (char *) "key", NULL
7097 };
7098
7099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7100 ecode1 = SWIG_AsVal_int(obj0, &val1);
7101 if (!SWIG_IsOK(ecode1)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7103 }
7104 arg1 = static_cast< wxKeyCode >(val1);
7105 {
7106 if (!wxPyCheckForApp()) SWIG_fail;
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = (bool)wxGetKeyState(arg1);
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 {
7113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7114 }
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7122 PyObject *resultobj = 0;
7123 wxMouseState *result = 0 ;
7124
7125 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7126 {
7127 PyThreadState* __tstate = wxPyBeginAllowThreads();
7128 result = (wxMouseState *)new wxMouseState();
7129 wxPyEndAllowThreads(__tstate);
7130 if (PyErr_Occurred()) SWIG_fail;
7131 }
7132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7140 PyObject *resultobj = 0;
7141 wxMouseState *arg1 = (wxMouseState *) 0 ;
7142 void *argp1 = 0 ;
7143 int res1 = 0 ;
7144 PyObject *swig_obj[1] ;
7145
7146 if (!args) SWIG_fail;
7147 swig_obj[0] = args;
7148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7151 }
7152 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 delete arg1;
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 resultobj = SWIG_Py_Void();
7161 return resultobj;
7162 fail:
7163 return NULL;
7164 }
7165
7166
7167 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7168 PyObject *resultobj = 0;
7169 wxMouseState *arg1 = (wxMouseState *) 0 ;
7170 int result;
7171 void *argp1 = 0 ;
7172 int res1 = 0 ;
7173 PyObject *swig_obj[1] ;
7174
7175 if (!args) SWIG_fail;
7176 swig_obj[0] = args;
7177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7178 if (!SWIG_IsOK(res1)) {
7179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7180 }
7181 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7182 {
7183 PyThreadState* __tstate = wxPyBeginAllowThreads();
7184 result = (int)(arg1)->GetX();
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 resultobj = SWIG_From_int(static_cast< int >(result));
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7196 PyObject *resultobj = 0;
7197 wxMouseState *arg1 = (wxMouseState *) 0 ;
7198 int result;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 PyObject *swig_obj[1] ;
7202
7203 if (!args) SWIG_fail;
7204 swig_obj[0] = args;
7205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7206 if (!SWIG_IsOK(res1)) {
7207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7208 }
7209 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7210 {
7211 PyThreadState* __tstate = wxPyBeginAllowThreads();
7212 result = (int)(arg1)->GetY();
7213 wxPyEndAllowThreads(__tstate);
7214 if (PyErr_Occurred()) SWIG_fail;
7215 }
7216 resultobj = SWIG_From_int(static_cast< int >(result));
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7224 PyObject *resultobj = 0;
7225 wxMouseState *arg1 = (wxMouseState *) 0 ;
7226 bool result;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 PyObject *swig_obj[1] ;
7230
7231 if (!args) SWIG_fail;
7232 swig_obj[0] = args;
7233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7234 if (!SWIG_IsOK(res1)) {
7235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7236 }
7237 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 result = (bool)(arg1)->LeftDown();
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 {
7245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7246 }
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7254 PyObject *resultobj = 0;
7255 wxMouseState *arg1 = (wxMouseState *) 0 ;
7256 bool result;
7257 void *argp1 = 0 ;
7258 int res1 = 0 ;
7259 PyObject *swig_obj[1] ;
7260
7261 if (!args) SWIG_fail;
7262 swig_obj[0] = args;
7263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7264 if (!SWIG_IsOK(res1)) {
7265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7266 }
7267 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)(arg1)->MiddleDown();
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7284 PyObject *resultobj = 0;
7285 wxMouseState *arg1 = (wxMouseState *) 0 ;
7286 bool result;
7287 void *argp1 = 0 ;
7288 int res1 = 0 ;
7289 PyObject *swig_obj[1] ;
7290
7291 if (!args) SWIG_fail;
7292 swig_obj[0] = args;
7293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7296 }
7297 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 result = (bool)(arg1)->RightDown();
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 {
7305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7306 }
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7314 PyObject *resultobj = 0;
7315 wxMouseState *arg1 = (wxMouseState *) 0 ;
7316 bool result;
7317 void *argp1 = 0 ;
7318 int res1 = 0 ;
7319 PyObject *swig_obj[1] ;
7320
7321 if (!args) SWIG_fail;
7322 swig_obj[0] = args;
7323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7324 if (!SWIG_IsOK(res1)) {
7325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7326 }
7327 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 result = (bool)(arg1)->ControlDown();
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 {
7335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7336 }
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7344 PyObject *resultobj = 0;
7345 wxMouseState *arg1 = (wxMouseState *) 0 ;
7346 bool result;
7347 void *argp1 = 0 ;
7348 int res1 = 0 ;
7349 PyObject *swig_obj[1] ;
7350
7351 if (!args) SWIG_fail;
7352 swig_obj[0] = args;
7353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7354 if (!SWIG_IsOK(res1)) {
7355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7356 }
7357 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (bool)(arg1)->ShiftDown();
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 {
7365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7366 }
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7374 PyObject *resultobj = 0;
7375 wxMouseState *arg1 = (wxMouseState *) 0 ;
7376 bool result;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 PyObject *swig_obj[1] ;
7380
7381 if (!args) SWIG_fail;
7382 swig_obj[0] = args;
7383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7386 }
7387 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7388 {
7389 PyThreadState* __tstate = wxPyBeginAllowThreads();
7390 result = (bool)(arg1)->AltDown();
7391 wxPyEndAllowThreads(__tstate);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 {
7395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7396 }
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7404 PyObject *resultobj = 0;
7405 wxMouseState *arg1 = (wxMouseState *) 0 ;
7406 bool result;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 PyObject *swig_obj[1] ;
7410
7411 if (!args) SWIG_fail;
7412 swig_obj[0] = args;
7413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7416 }
7417 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (bool)(arg1)->MetaDown();
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 {
7425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7426 }
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434 PyObject *resultobj = 0;
7435 wxMouseState *arg1 = (wxMouseState *) 0 ;
7436 bool result;
7437 void *argp1 = 0 ;
7438 int res1 = 0 ;
7439 PyObject *swig_obj[1] ;
7440
7441 if (!args) SWIG_fail;
7442 swig_obj[0] = args;
7443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7446 }
7447 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)(arg1)->CmdDown();
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxMouseState *arg1 = (wxMouseState *) 0 ;
7466 int arg2 ;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 int val2 ;
7470 int ecode2 = 0 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "x", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7481 }
7482 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7483 ecode2 = SWIG_AsVal_int(obj1, &val2);
7484 if (!SWIG_IsOK(ecode2)) {
7485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7486 }
7487 arg2 = static_cast< int >(val2);
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->SetX(arg2);
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = SWIG_Py_Void();
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = 0;
7503 wxMouseState *arg1 = (wxMouseState *) 0 ;
7504 int arg2 ;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 int val2 ;
7508 int ecode2 = 0 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "y", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7519 }
7520 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7521 ecode2 = SWIG_AsVal_int(obj1, &val2);
7522 if (!SWIG_IsOK(ecode2)) {
7523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7524 }
7525 arg2 = static_cast< int >(val2);
7526 {
7527 PyThreadState* __tstate = wxPyBeginAllowThreads();
7528 (arg1)->SetY(arg2);
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 resultobj = SWIG_Py_Void();
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = 0;
7541 wxMouseState *arg1 = (wxMouseState *) 0 ;
7542 bool arg2 ;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 bool val2 ;
7546 int ecode2 = 0 ;
7547 PyObject * obj0 = 0 ;
7548 PyObject * obj1 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "down", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7557 }
7558 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7560 if (!SWIG_IsOK(ecode2)) {
7561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7562 }
7563 arg2 = static_cast< bool >(val2);
7564 {
7565 PyThreadState* __tstate = wxPyBeginAllowThreads();
7566 (arg1)->SetLeftDown(arg2);
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 resultobj = SWIG_Py_Void();
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj = 0;
7579 wxMouseState *arg1 = (wxMouseState *) 0 ;
7580 bool arg2 ;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 bool val2 ;
7584 int ecode2 = 0 ;
7585 PyObject * obj0 = 0 ;
7586 PyObject * obj1 = 0 ;
7587 char * kwnames[] = {
7588 (char *) "self",(char *) "down", NULL
7589 };
7590
7591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7593 if (!SWIG_IsOK(res1)) {
7594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7595 }
7596 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7597 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7598 if (!SWIG_IsOK(ecode2)) {
7599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7600 }
7601 arg2 = static_cast< bool >(val2);
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 (arg1)->SetMiddleDown(arg2);
7605 wxPyEndAllowThreads(__tstate);
7606 if (PyErr_Occurred()) SWIG_fail;
7607 }
7608 resultobj = SWIG_Py_Void();
7609 return resultobj;
7610 fail:
7611 return NULL;
7612 }
7613
7614
7615 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7616 PyObject *resultobj = 0;
7617 wxMouseState *arg1 = (wxMouseState *) 0 ;
7618 bool arg2 ;
7619 void *argp1 = 0 ;
7620 int res1 = 0 ;
7621 bool val2 ;
7622 int ecode2 = 0 ;
7623 PyObject * obj0 = 0 ;
7624 PyObject * obj1 = 0 ;
7625 char * kwnames[] = {
7626 (char *) "self",(char *) "down", NULL
7627 };
7628
7629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7631 if (!SWIG_IsOK(res1)) {
7632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7633 }
7634 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7635 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7636 if (!SWIG_IsOK(ecode2)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7638 }
7639 arg2 = static_cast< bool >(val2);
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 (arg1)->SetRightDown(arg2);
7643 wxPyEndAllowThreads(__tstate);
7644 if (PyErr_Occurred()) SWIG_fail;
7645 }
7646 resultobj = SWIG_Py_Void();
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj = 0;
7655 wxMouseState *arg1 = (wxMouseState *) 0 ;
7656 bool arg2 ;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 bool val2 ;
7660 int ecode2 = 0 ;
7661 PyObject * obj0 = 0 ;
7662 PyObject * obj1 = 0 ;
7663 char * kwnames[] = {
7664 (char *) "self",(char *) "down", NULL
7665 };
7666
7667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7669 if (!SWIG_IsOK(res1)) {
7670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7671 }
7672 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7673 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7674 if (!SWIG_IsOK(ecode2)) {
7675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7676 }
7677 arg2 = static_cast< bool >(val2);
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 (arg1)->SetControlDown(arg2);
7681 wxPyEndAllowThreads(__tstate);
7682 if (PyErr_Occurred()) SWIG_fail;
7683 }
7684 resultobj = SWIG_Py_Void();
7685 return resultobj;
7686 fail:
7687 return NULL;
7688 }
7689
7690
7691 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7692 PyObject *resultobj = 0;
7693 wxMouseState *arg1 = (wxMouseState *) 0 ;
7694 bool arg2 ;
7695 void *argp1 = 0 ;
7696 int res1 = 0 ;
7697 bool val2 ;
7698 int ecode2 = 0 ;
7699 PyObject * obj0 = 0 ;
7700 PyObject * obj1 = 0 ;
7701 char * kwnames[] = {
7702 (char *) "self",(char *) "down", NULL
7703 };
7704
7705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7707 if (!SWIG_IsOK(res1)) {
7708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7709 }
7710 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7712 if (!SWIG_IsOK(ecode2)) {
7713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7714 }
7715 arg2 = static_cast< bool >(val2);
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 (arg1)->SetShiftDown(arg2);
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 resultobj = SWIG_Py_Void();
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj = 0;
7731 wxMouseState *arg1 = (wxMouseState *) 0 ;
7732 bool arg2 ;
7733 void *argp1 = 0 ;
7734 int res1 = 0 ;
7735 bool val2 ;
7736 int ecode2 = 0 ;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 char * kwnames[] = {
7740 (char *) "self",(char *) "down", NULL
7741 };
7742
7743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7747 }
7748 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7749 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7750 if (!SWIG_IsOK(ecode2)) {
7751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7752 }
7753 arg2 = static_cast< bool >(val2);
7754 {
7755 PyThreadState* __tstate = wxPyBeginAllowThreads();
7756 (arg1)->SetAltDown(arg2);
7757 wxPyEndAllowThreads(__tstate);
7758 if (PyErr_Occurred()) SWIG_fail;
7759 }
7760 resultobj = SWIG_Py_Void();
7761 return resultobj;
7762 fail:
7763 return NULL;
7764 }
7765
7766
7767 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj = 0;
7769 wxMouseState *arg1 = (wxMouseState *) 0 ;
7770 bool arg2 ;
7771 void *argp1 = 0 ;
7772 int res1 = 0 ;
7773 bool val2 ;
7774 int ecode2 = 0 ;
7775 PyObject * obj0 = 0 ;
7776 PyObject * obj1 = 0 ;
7777 char * kwnames[] = {
7778 (char *) "self",(char *) "down", NULL
7779 };
7780
7781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7785 }
7786 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7787 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7788 if (!SWIG_IsOK(ecode2)) {
7789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7790 }
7791 arg2 = static_cast< bool >(val2);
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 (arg1)->SetMetaDown(arg2);
7795 wxPyEndAllowThreads(__tstate);
7796 if (PyErr_Occurred()) SWIG_fail;
7797 }
7798 resultobj = SWIG_Py_Void();
7799 return resultobj;
7800 fail:
7801 return NULL;
7802 }
7803
7804
7805 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7806 PyObject *obj;
7807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7808 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7809 return SWIG_Py_Void();
7810 }
7811
7812 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7813 return SWIG_Python_InitShadowInstance(args);
7814 }
7815
7816 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7817 PyObject *resultobj = 0;
7818 wxMouseState result;
7819
7820 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = wxGetMouseState();
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7835 PyObject *resultobj = 0;
7836
7837 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7838 {
7839 if (!wxPyCheckForApp()) SWIG_fail;
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 wxWakeUpMainThread();
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_Py_Void();
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7853 PyObject *resultobj = 0;
7854
7855 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7856 {
7857 if (!wxPyCheckForApp()) SWIG_fail;
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 wxMutexGuiEnter();
7860 wxPyEndAllowThreads(__tstate);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 resultobj = SWIG_Py_Void();
7864 return resultobj;
7865 fail:
7866 return NULL;
7867 }
7868
7869
7870 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7871 PyObject *resultobj = 0;
7872
7873 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7874 {
7875 if (!wxPyCheckForApp()) SWIG_fail;
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 wxMutexGuiLeave();
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 resultobj = SWIG_Py_Void();
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7889 PyObject *resultobj = 0;
7890 wxMutexGuiLocker *result = 0 ;
7891
7892 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7893 {
7894 if (!wxPyCheckForApp()) SWIG_fail;
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7897 wxPyEndAllowThreads(__tstate);
7898 if (PyErr_Occurred()) SWIG_fail;
7899 }
7900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7901 return resultobj;
7902 fail:
7903 return NULL;
7904 }
7905
7906
7907 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7908 PyObject *resultobj = 0;
7909 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7910 void *argp1 = 0 ;
7911 int res1 = 0 ;
7912 PyObject *swig_obj[1] ;
7913
7914 if (!args) SWIG_fail;
7915 swig_obj[0] = args;
7916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7917 if (!SWIG_IsOK(res1)) {
7918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7919 }
7920 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 delete arg1;
7924
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 resultobj = SWIG_Py_Void();
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *obj;
7937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7938 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7939 return SWIG_Py_Void();
7940 }
7941
7942 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7943 return SWIG_Python_InitShadowInstance(args);
7944 }
7945
7946 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7947 PyObject *resultobj = 0;
7948 bool result;
7949
7950 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 result = (bool)wxThread_IsMain();
7954 wxPyEndAllowThreads(__tstate);
7955 if (PyErr_Occurred()) SWIG_fail;
7956 }
7957 {
7958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7959 }
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 wxString *arg1 = 0 ;
7969 wxToolTip *result = 0 ;
7970 bool temp1 = false ;
7971 PyObject * obj0 = 0 ;
7972 char * kwnames[] = {
7973 (char *) "tip", NULL
7974 };
7975
7976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7977 {
7978 arg1 = wxString_in_helper(obj0);
7979 if (arg1 == NULL) SWIG_fail;
7980 temp1 = true;
7981 }
7982 {
7983 if (!wxPyCheckForApp()) SWIG_fail;
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7990 {
7991 if (temp1)
7992 delete arg1;
7993 }
7994 return resultobj;
7995 fail:
7996 {
7997 if (temp1)
7998 delete arg1;
7999 }
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *resultobj = 0;
8006 wxToolTip *arg1 = (wxToolTip *) 0 ;
8007 void *argp1 = 0 ;
8008 int res1 = 0 ;
8009 PyObject *swig_obj[1] ;
8010
8011 if (!args) SWIG_fail;
8012 swig_obj[0] = args;
8013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8014 if (!SWIG_IsOK(res1)) {
8015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8016 }
8017 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8018 {
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 delete arg1;
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_Py_Void();
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj = 0;
8034 wxToolTip *arg1 = (wxToolTip *) 0 ;
8035 wxString *arg2 = 0 ;
8036 void *argp1 = 0 ;
8037 int res1 = 0 ;
8038 bool temp2 = false ;
8039 PyObject * obj0 = 0 ;
8040 PyObject * obj1 = 0 ;
8041 char * kwnames[] = {
8042 (char *) "self",(char *) "tip", NULL
8043 };
8044
8045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8047 if (!SWIG_IsOK(res1)) {
8048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8049 }
8050 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8051 {
8052 arg2 = wxString_in_helper(obj1);
8053 if (arg2 == NULL) SWIG_fail;
8054 temp2 = true;
8055 }
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 (arg1)->SetTip((wxString const &)*arg2);
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_Py_Void();
8063 {
8064 if (temp2)
8065 delete arg2;
8066 }
8067 return resultobj;
8068 fail:
8069 {
8070 if (temp2)
8071 delete arg2;
8072 }
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxToolTip *arg1 = (wxToolTip *) 0 ;
8080 wxString result;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 PyObject *swig_obj[1] ;
8084
8085 if (!args) SWIG_fail;
8086 swig_obj[0] = args;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8090 }
8091 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8092 {
8093 PyThreadState* __tstate = wxPyBeginAllowThreads();
8094 result = (arg1)->GetTip();
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 {
8099 #if wxUSE_UNICODE
8100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8101 #else
8102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8103 #endif
8104 }
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8112 PyObject *resultobj = 0;
8113 wxToolTip *arg1 = (wxToolTip *) 0 ;
8114 wxWindow *result = 0 ;
8115 void *argp1 = 0 ;
8116 int res1 = 0 ;
8117 PyObject *swig_obj[1] ;
8118
8119 if (!args) SWIG_fail;
8120 swig_obj[0] = args;
8121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8122 if (!SWIG_IsOK(res1)) {
8123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8124 }
8125 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 result = (wxWindow *)(arg1)->GetWindow();
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 {
8133 resultobj = wxPyMake_wxObject(result, 0);
8134 }
8135 return resultobj;
8136 fail:
8137 return NULL;
8138 }
8139
8140
8141 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8142 PyObject *resultobj = 0;
8143 bool arg1 ;
8144 bool val1 ;
8145 int ecode1 = 0 ;
8146 PyObject * obj0 = 0 ;
8147 char * kwnames[] = {
8148 (char *) "flag", NULL
8149 };
8150
8151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8152 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8153 if (!SWIG_IsOK(ecode1)) {
8154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8155 }
8156 arg1 = static_cast< bool >(val1);
8157 {
8158 PyThreadState* __tstate = wxPyBeginAllowThreads();
8159 wxToolTip::Enable(arg1);
8160 wxPyEndAllowThreads(__tstate);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 resultobj = SWIG_Py_Void();
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8171 PyObject *resultobj = 0;
8172 long arg1 ;
8173 long val1 ;
8174 int ecode1 = 0 ;
8175 PyObject * obj0 = 0 ;
8176 char * kwnames[] = {
8177 (char *) "milliseconds", NULL
8178 };
8179
8180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8181 ecode1 = SWIG_AsVal_long(obj0, &val1);
8182 if (!SWIG_IsOK(ecode1)) {
8183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8184 }
8185 arg1 = static_cast< long >(val1);
8186 {
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 wxToolTip::SetDelay(arg1);
8189 wxPyEndAllowThreads(__tstate);
8190 if (PyErr_Occurred()) SWIG_fail;
8191 }
8192 resultobj = SWIG_Py_Void();
8193 return resultobj;
8194 fail:
8195 return NULL;
8196 }
8197
8198
8199 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8200 PyObject *obj;
8201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8202 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8203 return SWIG_Py_Void();
8204 }
8205
8206 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8207 return SWIG_Python_InitShadowInstance(args);
8208 }
8209
8210 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8211 PyObject *resultobj = 0;
8212 wxWindow *arg1 = (wxWindow *) 0 ;
8213 wxSize *arg2 = 0 ;
8214 wxCaret *result = 0 ;
8215 void *argp1 = 0 ;
8216 int res1 = 0 ;
8217 wxSize temp2 ;
8218 PyObject * obj0 = 0 ;
8219 PyObject * obj1 = 0 ;
8220 char * kwnames[] = {
8221 (char *) "window",(char *) "size", NULL
8222 };
8223
8224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8226 if (!SWIG_IsOK(res1)) {
8227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8228 }
8229 arg1 = reinterpret_cast< wxWindow * >(argp1);
8230 {
8231 arg2 = &temp2;
8232 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8233 }
8234 {
8235 if (!wxPyCheckForApp()) SWIG_fail;
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8249 PyObject *resultobj = 0;
8250 wxCaret *arg1 = (wxCaret *) 0 ;
8251 void *argp1 = 0 ;
8252 int res1 = 0 ;
8253 PyObject *swig_obj[1] ;
8254
8255 if (!args) SWIG_fail;
8256 swig_obj[0] = args;
8257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8260 }
8261 arg1 = reinterpret_cast< wxCaret * >(argp1);
8262 {
8263 PyThreadState* __tstate = wxPyBeginAllowThreads();
8264 delete arg1;
8265
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8277 PyObject *resultobj = 0;
8278 wxCaret *arg1 = (wxCaret *) 0 ;
8279 void *argp1 = 0 ;
8280 int res1 = 0 ;
8281 PyObject *swig_obj[1] ;
8282
8283 if (!args) SWIG_fail;
8284 swig_obj[0] = args;
8285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8286 if (!SWIG_IsOK(res1)) {
8287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8288 }
8289 arg1 = reinterpret_cast< wxCaret * >(argp1);
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 wxCaret_Destroy(arg1);
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 resultobj = SWIG_Py_Void();
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8304 PyObject *resultobj = 0;
8305 wxCaret *arg1 = (wxCaret *) 0 ;
8306 bool result;
8307 void *argp1 = 0 ;
8308 int res1 = 0 ;
8309 PyObject *swig_obj[1] ;
8310
8311 if (!args) SWIG_fail;
8312 swig_obj[0] = args;
8313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8314 if (!SWIG_IsOK(res1)) {
8315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8316 }
8317 arg1 = reinterpret_cast< wxCaret * >(argp1);
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 result = (bool)(arg1)->IsOk();
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 {
8325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8326 }
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334 PyObject *resultobj = 0;
8335 wxCaret *arg1 = (wxCaret *) 0 ;
8336 bool result;
8337 void *argp1 = 0 ;
8338 int res1 = 0 ;
8339 PyObject *swig_obj[1] ;
8340
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8346 }
8347 arg1 = reinterpret_cast< wxCaret * >(argp1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (bool)(arg1)->IsVisible();
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 {
8355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8356 }
8357 return resultobj;
8358 fail:
8359 return NULL;
8360 }
8361
8362
8363 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8364 PyObject *resultobj = 0;
8365 wxCaret *arg1 = (wxCaret *) 0 ;
8366 wxPoint result;
8367 void *argp1 = 0 ;
8368 int res1 = 0 ;
8369 PyObject *swig_obj[1] ;
8370
8371 if (!args) SWIG_fail;
8372 swig_obj[0] = args;
8373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8374 if (!SWIG_IsOK(res1)) {
8375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8376 }
8377 arg1 = reinterpret_cast< wxCaret * >(argp1);
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (arg1)->GetPosition();
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8392 PyObject *resultobj = 0;
8393 wxCaret *arg1 = (wxCaret *) 0 ;
8394 int *arg2 = (int *) 0 ;
8395 int *arg3 = (int *) 0 ;
8396 void *argp1 = 0 ;
8397 int res1 = 0 ;
8398 int temp2 ;
8399 int res2 = SWIG_TMPOBJ ;
8400 int temp3 ;
8401 int res3 = SWIG_TMPOBJ ;
8402 PyObject *swig_obj[1] ;
8403
8404 arg2 = &temp2;
8405 arg3 = &temp3;
8406 if (!args) SWIG_fail;
8407 swig_obj[0] = args;
8408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8409 if (!SWIG_IsOK(res1)) {
8410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8411 }
8412 arg1 = reinterpret_cast< wxCaret * >(argp1);
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 (arg1)->GetPosition(arg2,arg3);
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 resultobj = SWIG_Py_Void();
8420 if (SWIG_IsTmpObj(res2)) {
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8422 } else {
8423 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8425 }
8426 if (SWIG_IsTmpObj(res3)) {
8427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8428 } else {
8429 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8431 }
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8439 PyObject *resultobj = 0;
8440 wxCaret *arg1 = (wxCaret *) 0 ;
8441 wxSize result;
8442 void *argp1 = 0 ;
8443 int res1 = 0 ;
8444 PyObject *swig_obj[1] ;
8445
8446 if (!args) SWIG_fail;
8447 swig_obj[0] = args;
8448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8449 if (!SWIG_IsOK(res1)) {
8450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8451 }
8452 arg1 = reinterpret_cast< wxCaret * >(argp1);
8453 {
8454 PyThreadState* __tstate = wxPyBeginAllowThreads();
8455 result = (arg1)->GetSize();
8456 wxPyEndAllowThreads(__tstate);
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8467 PyObject *resultobj = 0;
8468 wxCaret *arg1 = (wxCaret *) 0 ;
8469 int *arg2 = (int *) 0 ;
8470 int *arg3 = (int *) 0 ;
8471 void *argp1 = 0 ;
8472 int res1 = 0 ;
8473 int temp2 ;
8474 int res2 = SWIG_TMPOBJ ;
8475 int temp3 ;
8476 int res3 = SWIG_TMPOBJ ;
8477 PyObject *swig_obj[1] ;
8478
8479 arg2 = &temp2;
8480 arg3 = &temp3;
8481 if (!args) SWIG_fail;
8482 swig_obj[0] = args;
8483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8486 }
8487 arg1 = reinterpret_cast< wxCaret * >(argp1);
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 (arg1)->GetSize(arg2,arg3);
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 resultobj = SWIG_Py_Void();
8495 if (SWIG_IsTmpObj(res2)) {
8496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8497 } else {
8498 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8500 }
8501 if (SWIG_IsTmpObj(res3)) {
8502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8503 } else {
8504 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8506 }
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8514 PyObject *resultobj = 0;
8515 wxCaret *arg1 = (wxCaret *) 0 ;
8516 wxWindow *result = 0 ;
8517 void *argp1 = 0 ;
8518 int res1 = 0 ;
8519 PyObject *swig_obj[1] ;
8520
8521 if (!args) SWIG_fail;
8522 swig_obj[0] = args;
8523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8526 }
8527 arg1 = reinterpret_cast< wxCaret * >(argp1);
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 result = (wxWindow *)(arg1)->GetWindow();
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 resultobj = wxPyMake_wxObject(result, 0);
8536 }
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj = 0;
8545 wxCaret *arg1 = (wxCaret *) 0 ;
8546 int arg2 ;
8547 int arg3 ;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 int val2 ;
8551 int ecode2 = 0 ;
8552 int val3 ;
8553 int ecode3 = 0 ;
8554 PyObject * obj0 = 0 ;
8555 PyObject * obj1 = 0 ;
8556 PyObject * obj2 = 0 ;
8557 char * kwnames[] = {
8558 (char *) "self",(char *) "x",(char *) "y", NULL
8559 };
8560
8561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8565 }
8566 arg1 = reinterpret_cast< wxCaret * >(argp1);
8567 ecode2 = SWIG_AsVal_int(obj1, &val2);
8568 if (!SWIG_IsOK(ecode2)) {
8569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8570 }
8571 arg2 = static_cast< int >(val2);
8572 ecode3 = SWIG_AsVal_int(obj2, &val3);
8573 if (!SWIG_IsOK(ecode3)) {
8574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8575 }
8576 arg3 = static_cast< int >(val3);
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 (arg1)->Move(arg2,arg3);
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_Py_Void();
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxCaret *arg1 = (wxCaret *) 0 ;
8593 wxPoint *arg2 = 0 ;
8594 void *argp1 = 0 ;
8595 int res1 = 0 ;
8596 wxPoint temp2 ;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8599 char * kwnames[] = {
8600 (char *) "self",(char *) "pt", NULL
8601 };
8602
8603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8605 if (!SWIG_IsOK(res1)) {
8606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8607 }
8608 arg1 = reinterpret_cast< wxCaret * >(argp1);
8609 {
8610 arg2 = &temp2;
8611 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 (arg1)->Move((wxPoint const &)*arg2);
8616 wxPyEndAllowThreads(__tstate);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_Py_Void();
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxCaret *arg1 = (wxCaret *) 0 ;
8629 int arg2 ;
8630 int arg3 ;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 int val2 ;
8634 int ecode2 = 0 ;
8635 int val3 ;
8636 int ecode3 = 0 ;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 PyObject * obj2 = 0 ;
8640 char * kwnames[] = {
8641 (char *) "self",(char *) "width",(char *) "height", NULL
8642 };
8643
8644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8646 if (!SWIG_IsOK(res1)) {
8647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8648 }
8649 arg1 = reinterpret_cast< wxCaret * >(argp1);
8650 ecode2 = SWIG_AsVal_int(obj1, &val2);
8651 if (!SWIG_IsOK(ecode2)) {
8652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8653 }
8654 arg2 = static_cast< int >(val2);
8655 ecode3 = SWIG_AsVal_int(obj2, &val3);
8656 if (!SWIG_IsOK(ecode3)) {
8657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8658 }
8659 arg3 = static_cast< int >(val3);
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 (arg1)->SetSize(arg2,arg3);
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 resultobj = SWIG_Py_Void();
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj = 0;
8675 wxCaret *arg1 = (wxCaret *) 0 ;
8676 wxSize *arg2 = 0 ;
8677 void *argp1 = 0 ;
8678 int res1 = 0 ;
8679 wxSize temp2 ;
8680 PyObject * obj0 = 0 ;
8681 PyObject * obj1 = 0 ;
8682 char * kwnames[] = {
8683 (char *) "self",(char *) "size", NULL
8684 };
8685
8686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8688 if (!SWIG_IsOK(res1)) {
8689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8690 }
8691 arg1 = reinterpret_cast< wxCaret * >(argp1);
8692 {
8693 arg2 = &temp2;
8694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8695 }
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 (arg1)->SetSize((wxSize const &)*arg2);
8699 wxPyEndAllowThreads(__tstate);
8700 if (PyErr_Occurred()) SWIG_fail;
8701 }
8702 resultobj = SWIG_Py_Void();
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj = 0;
8711 wxCaret *arg1 = (wxCaret *) 0 ;
8712 int arg2 = (int) true ;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 int val2 ;
8716 int ecode2 = 0 ;
8717 PyObject * obj0 = 0 ;
8718 PyObject * obj1 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "show", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8727 }
8728 arg1 = reinterpret_cast< wxCaret * >(argp1);
8729 if (obj1) {
8730 ecode2 = SWIG_AsVal_int(obj1, &val2);
8731 if (!SWIG_IsOK(ecode2)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8733 }
8734 arg2 = static_cast< int >(val2);
8735 }
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 (arg1)->Show(arg2);
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 resultobj = SWIG_Py_Void();
8743 return resultobj;
8744 fail:
8745 return NULL;
8746 }
8747
8748
8749 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8750 PyObject *resultobj = 0;
8751 wxCaret *arg1 = (wxCaret *) 0 ;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 PyObject *swig_obj[1] ;
8755
8756 if (!args) SWIG_fail;
8757 swig_obj[0] = args;
8758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8759 if (!SWIG_IsOK(res1)) {
8760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8761 }
8762 arg1 = reinterpret_cast< wxCaret * >(argp1);
8763 {
8764 PyThreadState* __tstate = wxPyBeginAllowThreads();
8765 (arg1)->Hide();
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 resultobj = SWIG_Py_Void();
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8777 PyObject *resultobj = 0;
8778 int result;
8779
8780 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 result = (int)wxCaret::GetBlinkTime();
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 resultobj = SWIG_From_int(static_cast< int >(result));
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj = 0;
8796 int arg1 ;
8797 int val1 ;
8798 int ecode1 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 char * kwnames[] = {
8801 (char *) "milliseconds", NULL
8802 };
8803
8804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8805 ecode1 = SWIG_AsVal_int(obj0, &val1);
8806 if (!SWIG_IsOK(ecode1)) {
8807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8808 }
8809 arg1 = static_cast< int >(val1);
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 wxCaret::SetBlinkTime(arg1);
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 resultobj = SWIG_Py_Void();
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8824 PyObject *obj;
8825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8826 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8827 return SWIG_Py_Void();
8828 }
8829
8830 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 return SWIG_Python_InitShadowInstance(args);
8832 }
8833
8834 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj = 0;
8836 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8837 wxBusyCursor *result = 0 ;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 PyObject * obj0 = 0 ;
8841 char * kwnames[] = {
8842 (char *) "cursor", NULL
8843 };
8844
8845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8846 if (obj0) {
8847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8850 }
8851 arg1 = reinterpret_cast< wxCursor * >(argp1);
8852 }
8853 {
8854 if (!wxPyCheckForApp()) SWIG_fail;
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *resultobj = 0;
8869 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8870 void *argp1 = 0 ;
8871 int res1 = 0 ;
8872 PyObject *swig_obj[1] ;
8873
8874 if (!args) SWIG_fail;
8875 swig_obj[0] = args;
8876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8877 if (!SWIG_IsOK(res1)) {
8878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8879 }
8880 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8881 {
8882 PyThreadState* __tstate = wxPyBeginAllowThreads();
8883 delete arg1;
8884
8885 wxPyEndAllowThreads(__tstate);
8886 if (PyErr_Occurred()) SWIG_fail;
8887 }
8888 resultobj = SWIG_Py_Void();
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8896 PyObject *obj;
8897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8898 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8899 return SWIG_Py_Void();
8900 }
8901
8902 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8903 return SWIG_Python_InitShadowInstance(args);
8904 }
8905
8906 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxWindow *arg1 = (wxWindow *) NULL ;
8909 wxWindowDisabler *result = 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 PyObject * obj0 = 0 ;
8913 char * kwnames[] = {
8914 (char *) "winToSkip", NULL
8915 };
8916
8917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8918 if (obj0) {
8919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8920 if (!SWIG_IsOK(res1)) {
8921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8922 }
8923 arg1 = reinterpret_cast< wxWindow * >(argp1);
8924 }
8925 {
8926 if (!wxPyCheckForApp()) SWIG_fail;
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8940 PyObject *resultobj = 0;
8941 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8942 void *argp1 = 0 ;
8943 int res1 = 0 ;
8944 PyObject *swig_obj[1] ;
8945
8946 if (!args) SWIG_fail;
8947 swig_obj[0] = args;
8948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8949 if (!SWIG_IsOK(res1)) {
8950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8951 }
8952 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8953 {
8954 PyThreadState* __tstate = wxPyBeginAllowThreads();
8955 delete arg1;
8956
8957 wxPyEndAllowThreads(__tstate);
8958 if (PyErr_Occurred()) SWIG_fail;
8959 }
8960 resultobj = SWIG_Py_Void();
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8968 PyObject *obj;
8969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8970 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8971 return SWIG_Py_Void();
8972 }
8973
8974 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8975 return SWIG_Python_InitShadowInstance(args);
8976 }
8977
8978 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj = 0;
8980 wxString *arg1 = 0 ;
8981 wxBusyInfo *result = 0 ;
8982 bool temp1 = false ;
8983 PyObject * obj0 = 0 ;
8984 char * kwnames[] = {
8985 (char *) "message", NULL
8986 };
8987
8988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8989 {
8990 arg1 = wxString_in_helper(obj0);
8991 if (arg1 == NULL) SWIG_fail;
8992 temp1 = true;
8993 }
8994 {
8995 if (!wxPyCheckForApp()) SWIG_fail;
8996 PyThreadState* __tstate = wxPyBeginAllowThreads();
8997 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8998 wxPyEndAllowThreads(__tstate);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9002 {
9003 if (temp1)
9004 delete arg1;
9005 }
9006 return resultobj;
9007 fail:
9008 {
9009 if (temp1)
9010 delete arg1;
9011 }
9012 return NULL;
9013 }
9014
9015
9016 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9017 PyObject *resultobj = 0;
9018 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9019 void *argp1 = 0 ;
9020 int res1 = 0 ;
9021 PyObject *swig_obj[1] ;
9022
9023 if (!args) SWIG_fail;
9024 swig_obj[0] = args;
9025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9026 if (!SWIG_IsOK(res1)) {
9027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9028 }
9029 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 delete arg1;
9033
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 resultobj = SWIG_Py_Void();
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *obj;
9046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9047 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9048 return SWIG_Py_Void();
9049 }
9050
9051 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9052 return SWIG_Python_InitShadowInstance(args);
9053 }
9054
9055 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9056 PyObject *resultobj = 0;
9057 wxStopWatch *result = 0 ;
9058
9059 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 result = (wxStopWatch *)new wxStopWatch();
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj = 0;
9075 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9076 long arg2 = (long) 0 ;
9077 void *argp1 = 0 ;
9078 int res1 = 0 ;
9079 long val2 ;
9080 int ecode2 = 0 ;
9081 PyObject * obj0 = 0 ;
9082 PyObject * obj1 = 0 ;
9083 char * kwnames[] = {
9084 (char *) "self",(char *) "t0", NULL
9085 };
9086
9087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9091 }
9092 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9093 if (obj1) {
9094 ecode2 = SWIG_AsVal_long(obj1, &val2);
9095 if (!SWIG_IsOK(ecode2)) {
9096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9097 }
9098 arg2 = static_cast< long >(val2);
9099 }
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 (arg1)->Start(arg2);
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 resultobj = SWIG_Py_Void();
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 PyObject *resultobj = 0;
9115 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9116 void *argp1 = 0 ;
9117 int res1 = 0 ;
9118 PyObject *swig_obj[1] ;
9119
9120 if (!args) SWIG_fail;
9121 swig_obj[0] = args;
9122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9123 if (!SWIG_IsOK(res1)) {
9124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9125 }
9126 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9127 {
9128 PyThreadState* __tstate = wxPyBeginAllowThreads();
9129 (arg1)->Pause();
9130 wxPyEndAllowThreads(__tstate);
9131 if (PyErr_Occurred()) SWIG_fail;
9132 }
9133 resultobj = SWIG_Py_Void();
9134 return resultobj;
9135 fail:
9136 return NULL;
9137 }
9138
9139
9140 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9141 PyObject *resultobj = 0;
9142 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9143 void *argp1 = 0 ;
9144 int res1 = 0 ;
9145 PyObject *swig_obj[1] ;
9146
9147 if (!args) SWIG_fail;
9148 swig_obj[0] = args;
9149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9150 if (!SWIG_IsOK(res1)) {
9151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9152 }
9153 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9154 {
9155 PyThreadState* __tstate = wxPyBeginAllowThreads();
9156 (arg1)->Resume();
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 resultobj = SWIG_Py_Void();
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9168 PyObject *resultobj = 0;
9169 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9170 long result;
9171 void *argp1 = 0 ;
9172 int res1 = 0 ;
9173 PyObject *swig_obj[1] ;
9174
9175 if (!args) SWIG_fail;
9176 swig_obj[0] = args;
9177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9178 if (!SWIG_IsOK(res1)) {
9179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9180 }
9181 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9182 {
9183 PyThreadState* __tstate = wxPyBeginAllowThreads();
9184 result = (long)((wxStopWatch const *)arg1)->Time();
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 resultobj = SWIG_From_long(static_cast< long >(result));
9189 return resultobj;
9190 fail:
9191 return NULL;
9192 }
9193
9194
9195 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9196 PyObject *obj;
9197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9198 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9199 return SWIG_Py_Void();
9200 }
9201
9202 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9203 return SWIG_Python_InitShadowInstance(args);
9204 }
9205
9206 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9207 PyObject *resultobj = 0;
9208 int arg1 = (int) 9 ;
9209 int arg2 = (int) wxID_FILE1 ;
9210 wxFileHistory *result = 0 ;
9211 int val1 ;
9212 int ecode1 = 0 ;
9213 int val2 ;
9214 int ecode2 = 0 ;
9215 PyObject * obj0 = 0 ;
9216 PyObject * obj1 = 0 ;
9217 char * kwnames[] = {
9218 (char *) "maxFiles",(char *) "idBase", NULL
9219 };
9220
9221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9222 if (obj0) {
9223 ecode1 = SWIG_AsVal_int(obj0, &val1);
9224 if (!SWIG_IsOK(ecode1)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9226 }
9227 arg1 = static_cast< int >(val1);
9228 }
9229 if (obj1) {
9230 ecode2 = SWIG_AsVal_int(obj1, &val2);
9231 if (!SWIG_IsOK(ecode2)) {
9232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9233 }
9234 arg2 = static_cast< int >(val2);
9235 }
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9239 wxPyEndAllowThreads(__tstate);
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9250 PyObject *resultobj = 0;
9251 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9252 void *argp1 = 0 ;
9253 int res1 = 0 ;
9254 PyObject *swig_obj[1] ;
9255
9256 if (!args) SWIG_fail;
9257 swig_obj[0] = args;
9258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9261 }
9262 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 delete arg1;
9266
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 resultobj = SWIG_Py_Void();
9271 return resultobj;
9272 fail:
9273 return NULL;
9274 }
9275
9276
9277 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9278 PyObject *resultobj = 0;
9279 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9280 wxString *arg2 = 0 ;
9281 void *argp1 = 0 ;
9282 int res1 = 0 ;
9283 bool temp2 = false ;
9284 PyObject * obj0 = 0 ;
9285 PyObject * obj1 = 0 ;
9286 char * kwnames[] = {
9287 (char *) "self",(char *) "file", NULL
9288 };
9289
9290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9294 }
9295 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9296 {
9297 arg2 = wxString_in_helper(obj1);
9298 if (arg2 == NULL) SWIG_fail;
9299 temp2 = true;
9300 }
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 (arg1)->AddFileToHistory((wxString const &)*arg2);
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_Py_Void();
9308 {
9309 if (temp2)
9310 delete arg2;
9311 }
9312 return resultobj;
9313 fail:
9314 {
9315 if (temp2)
9316 delete arg2;
9317 }
9318 return NULL;
9319 }
9320
9321
9322 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9323 PyObject *resultobj = 0;
9324 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9325 int arg2 ;
9326 void *argp1 = 0 ;
9327 int res1 = 0 ;
9328 int val2 ;
9329 int ecode2 = 0 ;
9330 PyObject * obj0 = 0 ;
9331 PyObject * obj1 = 0 ;
9332 char * kwnames[] = {
9333 (char *) "self",(char *) "i", NULL
9334 };
9335
9336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9340 }
9341 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9342 ecode2 = SWIG_AsVal_int(obj1, &val2);
9343 if (!SWIG_IsOK(ecode2)) {
9344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9345 }
9346 arg2 = static_cast< int >(val2);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 (arg1)->RemoveFileFromHistory(arg2);
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_Py_Void();
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9363 int result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9373 }
9374 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_int(static_cast< int >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9389 PyObject *resultobj = 0;
9390 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9391 wxMenu *arg2 = (wxMenu *) 0 ;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 void *argp2 = 0 ;
9395 int res2 = 0 ;
9396 PyObject * obj0 = 0 ;
9397 PyObject * obj1 = 0 ;
9398 char * kwnames[] = {
9399 (char *) "self",(char *) "menu", NULL
9400 };
9401
9402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9404 if (!SWIG_IsOK(res1)) {
9405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9406 }
9407 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9409 if (!SWIG_IsOK(res2)) {
9410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9411 }
9412 arg2 = reinterpret_cast< wxMenu * >(argp2);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 (arg1)->UseMenu(arg2);
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_Py_Void();
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9427 PyObject *resultobj = 0;
9428 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9429 wxMenu *arg2 = (wxMenu *) 0 ;
9430 void *argp1 = 0 ;
9431 int res1 = 0 ;
9432 void *argp2 = 0 ;
9433 int res2 = 0 ;
9434 PyObject * obj0 = 0 ;
9435 PyObject * obj1 = 0 ;
9436 char * kwnames[] = {
9437 (char *) "self",(char *) "menu", NULL
9438 };
9439
9440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9442 if (!SWIG_IsOK(res1)) {
9443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9444 }
9445 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9447 if (!SWIG_IsOK(res2)) {
9448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9449 }
9450 arg2 = reinterpret_cast< wxMenu * >(argp2);
9451 {
9452 PyThreadState* __tstate = wxPyBeginAllowThreads();
9453 (arg1)->RemoveMenu(arg2);
9454 wxPyEndAllowThreads(__tstate);
9455 if (PyErr_Occurred()) SWIG_fail;
9456 }
9457 resultobj = SWIG_Py_Void();
9458 return resultobj;
9459 fail:
9460 return NULL;
9461 }
9462
9463
9464 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj = 0;
9466 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9467 wxConfigBase *arg2 = 0 ;
9468 void *argp1 = 0 ;
9469 int res1 = 0 ;
9470 void *argp2 = 0 ;
9471 int res2 = 0 ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9474 char * kwnames[] = {
9475 (char *) "self",(char *) "config", NULL
9476 };
9477
9478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9482 }
9483 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9484 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9485 if (!SWIG_IsOK(res2)) {
9486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9487 }
9488 if (!argp2) {
9489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9490 }
9491 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 (arg1)->Load(*arg2);
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 resultobj = SWIG_Py_Void();
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj = 0;
9507 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9508 wxConfigBase *arg2 = 0 ;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 void *argp2 = 0 ;
9512 int res2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "config", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9523 }
9524 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9525 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9526 if (!SWIG_IsOK(res2)) {
9527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9528 }
9529 if (!argp2) {
9530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9531 }
9532 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 (arg1)->Save(*arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9547 PyObject *resultobj = 0;
9548 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9549 void *argp1 = 0 ;
9550 int res1 = 0 ;
9551 PyObject *swig_obj[1] ;
9552
9553 if (!args) SWIG_fail;
9554 swig_obj[0] = args;
9555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9556 if (!SWIG_IsOK(res1)) {
9557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9558 }
9559 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9560 {
9561 PyThreadState* __tstate = wxPyBeginAllowThreads();
9562 (arg1)->AddFilesToMenu();
9563 wxPyEndAllowThreads(__tstate);
9564 if (PyErr_Occurred()) SWIG_fail;
9565 }
9566 resultobj = SWIG_Py_Void();
9567 return resultobj;
9568 fail:
9569 return NULL;
9570 }
9571
9572
9573 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9574 PyObject *resultobj = 0;
9575 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9576 wxMenu *arg2 = (wxMenu *) 0 ;
9577 void *argp1 = 0 ;
9578 int res1 = 0 ;
9579 void *argp2 = 0 ;
9580 int res2 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "menu", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9591 }
9592 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9594 if (!SWIG_IsOK(res2)) {
9595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9596 }
9597 arg2 = reinterpret_cast< wxMenu * >(argp2);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->AddFilesToMenu(arg2);
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9612 PyObject *resultobj = 0;
9613 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9614 int arg2 ;
9615 wxString result;
9616 void *argp1 = 0 ;
9617 int res1 = 0 ;
9618 int val2 ;
9619 int ecode2 = 0 ;
9620 PyObject * obj0 = 0 ;
9621 PyObject * obj1 = 0 ;
9622 char * kwnames[] = {
9623 (char *) "self",(char *) "i", NULL
9624 };
9625
9626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9628 if (!SWIG_IsOK(res1)) {
9629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9630 }
9631 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9632 ecode2 = SWIG_AsVal_int(obj1, &val2);
9633 if (!SWIG_IsOK(ecode2)) {
9634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9635 }
9636 arg2 = static_cast< int >(val2);
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 {
9644 #if wxUSE_UNICODE
9645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9646 #else
9647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9648 #endif
9649 }
9650 return resultobj;
9651 fail:
9652 return NULL;
9653 }
9654
9655
9656 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9657 PyObject *resultobj = 0;
9658 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9659 int result;
9660 void *argp1 = 0 ;
9661 int res1 = 0 ;
9662 PyObject *swig_obj[1] ;
9663
9664 if (!args) SWIG_fail;
9665 swig_obj[0] = args;
9666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9667 if (!SWIG_IsOK(res1)) {
9668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9669 }
9670 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 result = (int)((wxFileHistory const *)arg1)->GetCount();
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 resultobj = SWIG_From_int(static_cast< int >(result));
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9685 PyObject *obj;
9686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9687 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9688 return SWIG_Py_Void();
9689 }
9690
9691 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9692 return SWIG_Python_InitShadowInstance(args);
9693 }
9694
9695 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj = 0;
9697 wxString *arg1 = 0 ;
9698 wxString const &arg2_defvalue = wxPyEmptyString ;
9699 wxString *arg2 = (wxString *) &arg2_defvalue ;
9700 wxSingleInstanceChecker *result = 0 ;
9701 bool temp1 = false ;
9702 bool temp2 = false ;
9703 PyObject * obj0 = 0 ;
9704 PyObject * obj1 = 0 ;
9705 char * kwnames[] = {
9706 (char *) "name",(char *) "path", NULL
9707 };
9708
9709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9710 {
9711 arg1 = wxString_in_helper(obj0);
9712 if (arg1 == NULL) SWIG_fail;
9713 temp1 = true;
9714 }
9715 if (obj1) {
9716 {
9717 arg2 = wxString_in_helper(obj1);
9718 if (arg2 == NULL) SWIG_fail;
9719 temp2 = true;
9720 }
9721 }
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9729 {
9730 if (temp1)
9731 delete arg1;
9732 }
9733 {
9734 if (temp2)
9735 delete arg2;
9736 }
9737 return resultobj;
9738 fail:
9739 {
9740 if (temp1)
9741 delete arg1;
9742 }
9743 {
9744 if (temp2)
9745 delete arg2;
9746 }
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *resultobj = 0;
9753 wxSingleInstanceChecker *result = 0 ;
9754
9755 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9759 wxPyEndAllowThreads(__tstate);
9760 if (PyErr_Occurred()) SWIG_fail;
9761 }
9762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9770 PyObject *resultobj = 0;
9771 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9772 void *argp1 = 0 ;
9773 int res1 = 0 ;
9774 PyObject *swig_obj[1] ;
9775
9776 if (!args) SWIG_fail;
9777 swig_obj[0] = args;
9778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9779 if (!SWIG_IsOK(res1)) {
9780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9781 }
9782 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 delete arg1;
9786
9787 wxPyEndAllowThreads(__tstate);
9788 if (PyErr_Occurred()) SWIG_fail;
9789 }
9790 resultobj = SWIG_Py_Void();
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj = 0;
9799 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9800 wxString *arg2 = 0 ;
9801 wxString const &arg3_defvalue = wxPyEmptyString ;
9802 wxString *arg3 = (wxString *) &arg3_defvalue ;
9803 bool result;
9804 void *argp1 = 0 ;
9805 int res1 = 0 ;
9806 bool temp2 = false ;
9807 bool temp3 = false ;
9808 PyObject * obj0 = 0 ;
9809 PyObject * obj1 = 0 ;
9810 PyObject * obj2 = 0 ;
9811 char * kwnames[] = {
9812 (char *) "self",(char *) "name",(char *) "path", NULL
9813 };
9814
9815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9819 }
9820 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9821 {
9822 arg2 = wxString_in_helper(obj1);
9823 if (arg2 == NULL) SWIG_fail;
9824 temp2 = true;
9825 }
9826 if (obj2) {
9827 {
9828 arg3 = wxString_in_helper(obj2);
9829 if (arg3 == NULL) SWIG_fail;
9830 temp3 = true;
9831 }
9832 }
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 {
9840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9841 }
9842 {
9843 if (temp2)
9844 delete arg2;
9845 }
9846 {
9847 if (temp3)
9848 delete arg3;
9849 }
9850 return resultobj;
9851 fail:
9852 {
9853 if (temp2)
9854 delete arg2;
9855 }
9856 {
9857 if (temp3)
9858 delete arg3;
9859 }
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9867 bool result;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9877 }
9878 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 {
9886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9887 }
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 PyObject *obj;
9896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9897 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9898 return SWIG_Py_Void();
9899 }
9900
9901 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 return SWIG_Python_InitShadowInstance(args);
9903 }
9904
9905 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9906 PyObject *resultobj = 0;
9907 wxWindow *arg1 = (wxWindow *) 0 ;
9908 wxDC *arg2 = 0 ;
9909 bool result;
9910 void *argp1 = 0 ;
9911 int res1 = 0 ;
9912 void *argp2 = 0 ;
9913 int res2 = 0 ;
9914 PyObject * obj0 = 0 ;
9915 PyObject * obj1 = 0 ;
9916 char * kwnames[] = {
9917 (char *) "window",(char *) "dc", NULL
9918 };
9919
9920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9922 if (!SWIG_IsOK(res1)) {
9923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9924 }
9925 arg1 = reinterpret_cast< wxWindow * >(argp1);
9926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9927 if (!SWIG_IsOK(res2)) {
9928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9929 }
9930 if (!argp2) {
9931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9932 }
9933 arg2 = reinterpret_cast< wxDC * >(argp2);
9934 {
9935 PyThreadState* __tstate = wxPyBeginAllowThreads();
9936 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 {
9941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9942 }
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 PyObject *swig_obj[1] ;
9955
9956 if (!args) SWIG_fail;
9957 swig_obj[0] = args;
9958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9961 }
9962 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 delete arg1;
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 resultobj = SWIG_Py_Void();
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9978 PyObject *resultobj = 0;
9979 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9980 wxString result;
9981 void *argp1 = 0 ;
9982 int res1 = 0 ;
9983 PyObject *swig_obj[1] ;
9984
9985 if (!args) SWIG_fail;
9986 swig_obj[0] = args;
9987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9988 if (!SWIG_IsOK(res1)) {
9989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9990 }
9991 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9992 {
9993 PyThreadState* __tstate = wxPyBeginAllowThreads();
9994 result = (arg1)->GetTip();
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 {
9999 #if wxUSE_UNICODE
10000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10001 #else
10002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10003 #endif
10004 }
10005 return resultobj;
10006 fail:
10007 return NULL;
10008 }
10009
10010
10011 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10012 PyObject *resultobj = 0;
10013 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10014 size_t result;
10015 void *argp1 = 0 ;
10016 int res1 = 0 ;
10017 PyObject *swig_obj[1] ;
10018
10019 if (!args) SWIG_fail;
10020 swig_obj[0] = args;
10021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10022 if (!SWIG_IsOK(res1)) {
10023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10024 }
10025 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10026 {
10027 PyThreadState* __tstate = wxPyBeginAllowThreads();
10028 result = (size_t)(arg1)->GetCurrentTip();
10029 wxPyEndAllowThreads(__tstate);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10033 return resultobj;
10034 fail:
10035 return NULL;
10036 }
10037
10038
10039 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj = 0;
10041 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10042 wxString *arg2 = 0 ;
10043 wxString result;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 bool temp2 = false ;
10047 PyObject * obj0 = 0 ;
10048 PyObject * obj1 = 0 ;
10049 char * kwnames[] = {
10050 (char *) "self",(char *) "tip", NULL
10051 };
10052
10053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10055 if (!SWIG_IsOK(res1)) {
10056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10057 }
10058 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10059 {
10060 arg2 = wxString_in_helper(obj1);
10061 if (arg2 == NULL) SWIG_fail;
10062 temp2 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 {
10071 #if wxUSE_UNICODE
10072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10073 #else
10074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10075 #endif
10076 }
10077 {
10078 if (temp2)
10079 delete arg2;
10080 }
10081 return resultobj;
10082 fail:
10083 {
10084 if (temp2)
10085 delete arg2;
10086 }
10087 return NULL;
10088 }
10089
10090
10091 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10092 PyObject *obj;
10093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10094 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10095 return SWIG_Py_Void();
10096 }
10097
10098 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj = 0;
10100 size_t arg1 ;
10101 wxPyTipProvider *result = 0 ;
10102 size_t val1 ;
10103 int ecode1 = 0 ;
10104 PyObject * obj0 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "currentTip", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10110 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10111 if (!SWIG_IsOK(ecode1)) {
10112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10113 }
10114 arg1 = static_cast< size_t >(val1);
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10122 return resultobj;
10123 fail:
10124 return NULL;
10125 }
10126
10127
10128 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10129 PyObject *resultobj = 0;
10130 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10131 PyObject *arg2 = (PyObject *) 0 ;
10132 PyObject *arg3 = (PyObject *) 0 ;
10133 void *argp1 = 0 ;
10134 int res1 = 0 ;
10135 PyObject * obj0 = 0 ;
10136 PyObject * obj1 = 0 ;
10137 PyObject * obj2 = 0 ;
10138 char * kwnames[] = {
10139 (char *) "self",(char *) "self",(char *) "_class", NULL
10140 };
10141
10142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10144 if (!SWIG_IsOK(res1)) {
10145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10146 }
10147 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10148 arg2 = obj1;
10149 arg3 = obj2;
10150 {
10151 PyThreadState* __tstate = wxPyBeginAllowThreads();
10152 (arg1)->_setCallbackInfo(arg2,arg3);
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_Py_Void();
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *obj;
10165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10166 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10167 return SWIG_Py_Void();
10168 }
10169
10170 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10171 return SWIG_Python_InitShadowInstance(args);
10172 }
10173
10174 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxWindow *arg1 = (wxWindow *) 0 ;
10177 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10178 bool arg3 = (bool) true ;
10179 bool result;
10180 void *argp1 = 0 ;
10181 int res1 = 0 ;
10182 void *argp2 = 0 ;
10183 int res2 = 0 ;
10184 bool val3 ;
10185 int ecode3 = 0 ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 PyObject * obj2 = 0 ;
10189 char * kwnames[] = {
10190 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10191 };
10192
10193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10195 if (!SWIG_IsOK(res1)) {
10196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10197 }
10198 arg1 = reinterpret_cast< wxWindow * >(argp1);
10199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10200 if (!SWIG_IsOK(res2)) {
10201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10202 }
10203 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10204 if (obj2) {
10205 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10206 if (!SWIG_IsOK(ecode3)) {
10207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10208 }
10209 arg3 = static_cast< bool >(val3);
10210 }
10211 {
10212 if (!wxPyCheckForApp()) SWIG_fail;
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 result = (bool)wxShowTip(arg1,arg2,arg3);
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 {
10219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10220 }
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 wxString *arg1 = 0 ;
10230 size_t arg2 ;
10231 wxTipProvider *result = 0 ;
10232 bool temp1 = false ;
10233 size_t val2 ;
10234 int ecode2 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "filename",(char *) "currentTip", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10242 {
10243 arg1 = wxString_in_helper(obj0);
10244 if (arg1 == NULL) SWIG_fail;
10245 temp1 = true;
10246 }
10247 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10248 if (!SWIG_IsOK(ecode2)) {
10249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10250 }
10251 arg2 = static_cast< size_t >(val2);
10252 {
10253 if (!wxPyCheckForApp()) SWIG_fail;
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10260 {
10261 if (temp1)
10262 delete arg1;
10263 }
10264 return resultobj;
10265 fail:
10266 {
10267 if (temp1)
10268 delete arg1;
10269 }
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10275 PyObject *resultobj = 0;
10276 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10277 int arg2 = (int) wxID_ANY ;
10278 wxPyTimer *result = 0 ;
10279 void *argp1 = 0 ;
10280 int res1 = 0 ;
10281 int val2 ;
10282 int ecode2 = 0 ;
10283 PyObject * obj0 = 0 ;
10284 PyObject * obj1 = 0 ;
10285 char * kwnames[] = {
10286 (char *) "owner",(char *) "id", NULL
10287 };
10288
10289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10290 if (obj0) {
10291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10292 if (!SWIG_IsOK(res1)) {
10293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10294 }
10295 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10296 }
10297 if (obj1) {
10298 ecode2 = SWIG_AsVal_int(obj1, &val2);
10299 if (!SWIG_IsOK(ecode2)) {
10300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10301 }
10302 arg2 = static_cast< int >(val2);
10303 }
10304 {
10305 if (!wxPyCheckForApp()) SWIG_fail;
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10319 PyObject *resultobj = 0;
10320 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10321 void *argp1 = 0 ;
10322 int res1 = 0 ;
10323 PyObject *swig_obj[1] ;
10324
10325 if (!args) SWIG_fail;
10326 swig_obj[0] = args;
10327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10328 if (!SWIG_IsOK(res1)) {
10329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10330 }
10331 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 delete arg1;
10335
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 resultobj = SWIG_Py_Void();
10340 return resultobj;
10341 fail:
10342 return NULL;
10343 }
10344
10345
10346 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj = 0;
10348 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10349 PyObject *arg2 = (PyObject *) 0 ;
10350 PyObject *arg3 = (PyObject *) 0 ;
10351 int arg4 = (int) 1 ;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 int val4 ;
10355 int ecode4 = 0 ;
10356 PyObject * obj0 = 0 ;
10357 PyObject * obj1 = 0 ;
10358 PyObject * obj2 = 0 ;
10359 PyObject * obj3 = 0 ;
10360 char * kwnames[] = {
10361 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10362 };
10363
10364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10368 }
10369 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10370 arg2 = obj1;
10371 arg3 = obj2;
10372 if (obj3) {
10373 ecode4 = SWIG_AsVal_int(obj3, &val4);
10374 if (!SWIG_IsOK(ecode4)) {
10375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10376 }
10377 arg4 = static_cast< int >(val4);
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 resultobj = SWIG_Py_Void();
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj = 0;
10394 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10395 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10396 int arg3 = (int) wxID_ANY ;
10397 void *argp1 = 0 ;
10398 int res1 = 0 ;
10399 void *argp2 = 0 ;
10400 int res2 = 0 ;
10401 int val3 ;
10402 int ecode3 = 0 ;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 PyObject * obj2 = 0 ;
10406 char * kwnames[] = {
10407 (char *) "self",(char *) "owner",(char *) "id", NULL
10408 };
10409
10410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10414 }
10415 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10417 if (!SWIG_IsOK(res2)) {
10418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10419 }
10420 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10421 if (obj2) {
10422 ecode3 = SWIG_AsVal_int(obj2, &val3);
10423 if (!SWIG_IsOK(ecode3)) {
10424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10425 }
10426 arg3 = static_cast< int >(val3);
10427 }
10428 {
10429 PyThreadState* __tstate = wxPyBeginAllowThreads();
10430 (arg1)->SetOwner(arg2,arg3);
10431 wxPyEndAllowThreads(__tstate);
10432 if (PyErr_Occurred()) SWIG_fail;
10433 }
10434 resultobj = SWIG_Py_Void();
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10442 PyObject *resultobj = 0;
10443 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10444 wxEvtHandler *result = 0 ;
10445 void *argp1 = 0 ;
10446 int res1 = 0 ;
10447 PyObject *swig_obj[1] ;
10448
10449 if (!args) SWIG_fail;
10450 swig_obj[0] = args;
10451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10452 if (!SWIG_IsOK(res1)) {
10453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10454 }
10455 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10456 {
10457 PyThreadState* __tstate = wxPyBeginAllowThreads();
10458 result = (wxEvtHandler *)(arg1)->GetOwner();
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 {
10463 resultobj = wxPyMake_wxObject(result, 0);
10464 }
10465 return resultobj;
10466 fail:
10467 return NULL;
10468 }
10469
10470
10471 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10472 PyObject *resultobj = 0;
10473 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10474 int arg2 = (int) -1 ;
10475 bool arg3 = (bool) false ;
10476 bool result;
10477 void *argp1 = 0 ;
10478 int res1 = 0 ;
10479 int val2 ;
10480 int ecode2 = 0 ;
10481 bool val3 ;
10482 int ecode3 = 0 ;
10483 PyObject * obj0 = 0 ;
10484 PyObject * obj1 = 0 ;
10485 PyObject * obj2 = 0 ;
10486 char * kwnames[] = {
10487 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10488 };
10489
10490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10492 if (!SWIG_IsOK(res1)) {
10493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10494 }
10495 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10496 if (obj1) {
10497 ecode2 = SWIG_AsVal_int(obj1, &val2);
10498 if (!SWIG_IsOK(ecode2)) {
10499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10500 }
10501 arg2 = static_cast< int >(val2);
10502 }
10503 if (obj2) {
10504 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10505 if (!SWIG_IsOK(ecode3)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10507 }
10508 arg3 = static_cast< bool >(val3);
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (bool)(arg1)->Start(arg2,arg3);
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10518 }
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10526 PyObject *resultobj = 0;
10527 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10528 void *argp1 = 0 ;
10529 int res1 = 0 ;
10530 PyObject *swig_obj[1] ;
10531
10532 if (!args) SWIG_fail;
10533 swig_obj[0] = args;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10537 }
10538 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 (arg1)->Stop();
10542 wxPyEndAllowThreads(__tstate);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 resultobj = SWIG_Py_Void();
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *resultobj = 0;
10554 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10555 void *argp1 = 0 ;
10556 int res1 = 0 ;
10557 PyObject *swig_obj[1] ;
10558
10559 if (!args) SWIG_fail;
10560 swig_obj[0] = args;
10561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10562 if (!SWIG_IsOK(res1)) {
10563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10564 }
10565 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10566 {
10567 PyThreadState* __tstate = wxPyBeginAllowThreads();
10568 (arg1)->Notify();
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 resultobj = SWIG_Py_Void();
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10582 bool result;
10583 void *argp1 = 0 ;
10584 int res1 = 0 ;
10585 PyObject *swig_obj[1] ;
10586
10587 if (!args) SWIG_fail;
10588 swig_obj[0] = args;
10589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10590 if (!SWIG_IsOK(res1)) {
10591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10592 }
10593 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 {
10601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10602 }
10603 return resultobj;
10604 fail:
10605 return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 PyObject *resultobj = 0;
10611 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10612 int result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 PyObject *swig_obj[1] ;
10616
10617 if (!args) SWIG_fail;
10618 swig_obj[0] = args;
10619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10622 }
10623 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 resultobj = SWIG_From_int(static_cast< int >(result));
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10638 PyObject *resultobj = 0;
10639 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10640 int result;
10641 void *argp1 = 0 ;
10642 int res1 = 0 ;
10643 PyObject *swig_obj[1] ;
10644
10645 if (!args) SWIG_fail;
10646 swig_obj[0] = args;
10647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10648 if (!SWIG_IsOK(res1)) {
10649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10650 }
10651 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10652 {
10653 PyThreadState* __tstate = wxPyBeginAllowThreads();
10654 result = (int)((wxPyTimer const *)arg1)->GetId();
10655 wxPyEndAllowThreads(__tstate);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 }
10658 resultobj = SWIG_From_int(static_cast< int >(result));
10659 return resultobj;
10660 fail:
10661 return NULL;
10662 }
10663
10664
10665 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10666 PyObject *resultobj = 0;
10667 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10668 bool result;
10669 void *argp1 = 0 ;
10670 int res1 = 0 ;
10671 PyObject *swig_obj[1] ;
10672
10673 if (!args) SWIG_fail;
10674 swig_obj[0] = args;
10675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10676 if (!SWIG_IsOK(res1)) {
10677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10678 }
10679 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10680 {
10681 PyThreadState* __tstate = wxPyBeginAllowThreads();
10682 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 {
10687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10688 }
10689 return resultobj;
10690 fail:
10691 return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *obj;
10697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10698 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10699 return SWIG_Py_Void();
10700 }
10701
10702 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10703 return SWIG_Python_InitShadowInstance(args);
10704 }
10705
10706 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10707 PyObject *resultobj = 0;
10708 int arg1 = (int) 0 ;
10709 int arg2 = (int) 0 ;
10710 wxTimerEvent *result = 0 ;
10711 int val1 ;
10712 int ecode1 = 0 ;
10713 int val2 ;
10714 int ecode2 = 0 ;
10715 PyObject * obj0 = 0 ;
10716 PyObject * obj1 = 0 ;
10717 char * kwnames[] = {
10718 (char *) "timerid",(char *) "interval", NULL
10719 };
10720
10721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10722 if (obj0) {
10723 ecode1 = SWIG_AsVal_int(obj0, &val1);
10724 if (!SWIG_IsOK(ecode1)) {
10725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10726 }
10727 arg1 = static_cast< int >(val1);
10728 }
10729 if (obj1) {
10730 ecode2 = SWIG_AsVal_int(obj1, &val2);
10731 if (!SWIG_IsOK(ecode2)) {
10732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10733 }
10734 arg2 = static_cast< int >(val2);
10735 }
10736 {
10737 PyThreadState* __tstate = wxPyBeginAllowThreads();
10738 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10750 PyObject *resultobj = 0;
10751 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10752 int result;
10753 void *argp1 = 0 ;
10754 int res1 = 0 ;
10755 PyObject *swig_obj[1] ;
10756
10757 if (!args) SWIG_fail;
10758 swig_obj[0] = args;
10759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10760 if (!SWIG_IsOK(res1)) {
10761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10762 }
10763 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10767 wxPyEndAllowThreads(__tstate);
10768 if (PyErr_Occurred()) SWIG_fail;
10769 }
10770 resultobj = SWIG_From_int(static_cast< int >(result));
10771 return resultobj;
10772 fail:
10773 return NULL;
10774 }
10775
10776
10777 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10778 PyObject *obj;
10779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10780 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10781 return SWIG_Py_Void();
10782 }
10783
10784 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10785 return SWIG_Python_InitShadowInstance(args);
10786 }
10787
10788 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10789 PyObject *resultobj = 0;
10790 wxTimer *arg1 = 0 ;
10791 wxTimerRunner *result = 0 ;
10792 void *argp1 = 0 ;
10793 int res1 = 0 ;
10794
10795 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10799 }
10800 if (!argp1) {
10801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10802 }
10803 arg1 = reinterpret_cast< wxTimer * >(argp1);
10804 {
10805 if (!wxPyCheckForApp()) SWIG_fail;
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10819 PyObject *resultobj = 0;
10820 wxTimer *arg1 = 0 ;
10821 int arg2 ;
10822 bool arg3 = (bool) false ;
10823 wxTimerRunner *result = 0 ;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 int val2 ;
10827 int ecode2 = 0 ;
10828 bool val3 ;
10829 int ecode3 = 0 ;
10830
10831 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10833 if (!SWIG_IsOK(res1)) {
10834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10835 }
10836 if (!argp1) {
10837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10838 }
10839 arg1 = reinterpret_cast< wxTimer * >(argp1);
10840 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10841 if (!SWIG_IsOK(ecode2)) {
10842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10843 }
10844 arg2 = static_cast< int >(val2);
10845 if (swig_obj[2]) {
10846 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10847 if (!SWIG_IsOK(ecode3)) {
10848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10849 }
10850 arg3 = static_cast< bool >(val3);
10851 }
10852 {
10853 if (!wxPyCheckForApp()) SWIG_fail;
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10867 int argc;
10868 PyObject *argv[4];
10869
10870 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10871 --argc;
10872 if (argc == 1) {
10873 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10874 }
10875 if ((argc >= 2) && (argc <= 3)) {
10876 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10877 }
10878
10879 fail:
10880 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *resultobj = 0;
10887 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10888 void *argp1 = 0 ;
10889 int res1 = 0 ;
10890 PyObject *swig_obj[1] ;
10891
10892 if (!args) SWIG_fail;
10893 swig_obj[0] = args;
10894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10895 if (!SWIG_IsOK(res1)) {
10896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10897 }
10898 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 delete arg1;
10902
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = SWIG_Py_Void();
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj = 0;
10915 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10916 int arg2 ;
10917 bool arg3 = (bool) false ;
10918 void *argp1 = 0 ;
10919 int res1 = 0 ;
10920 int val2 ;
10921 int ecode2 = 0 ;
10922 bool val3 ;
10923 int ecode3 = 0 ;
10924 PyObject * obj0 = 0 ;
10925 PyObject * obj1 = 0 ;
10926 PyObject * obj2 = 0 ;
10927 char * kwnames[] = {
10928 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10929 };
10930
10931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10933 if (!SWIG_IsOK(res1)) {
10934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10935 }
10936 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10937 ecode2 = SWIG_AsVal_int(obj1, &val2);
10938 if (!SWIG_IsOK(ecode2)) {
10939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10940 }
10941 arg2 = static_cast< int >(val2);
10942 if (obj2) {
10943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10944 if (!SWIG_IsOK(ecode3)) {
10945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10946 }
10947 arg3 = static_cast< bool >(val3);
10948 }
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 (arg1)->Start(arg2,arg3);
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 resultobj = SWIG_Py_Void();
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *obj;
10964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10965 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10966 return SWIG_Py_Void();
10967 }
10968
10969 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10970 return SWIG_Python_InitShadowInstance(args);
10971 }
10972
10973 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10974 PyObject *resultobj = 0;
10975 wxLog *result = 0 ;
10976
10977 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10978 {
10979 PyThreadState* __tstate = wxPyBeginAllowThreads();
10980 result = (wxLog *)new wxLog();
10981 wxPyEndAllowThreads(__tstate);
10982 if (PyErr_Occurred()) SWIG_fail;
10983 }
10984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10985 return resultobj;
10986 fail:
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10992 PyObject *resultobj = 0;
10993 wxLog *arg1 = (wxLog *) 0 ;
10994 void *argp1 = 0 ;
10995 int res1 = 0 ;
10996 PyObject *swig_obj[1] ;
10997
10998 if (!args) SWIG_fail;
10999 swig_obj[0] = args;
11000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11003 }
11004 arg1 = reinterpret_cast< wxLog * >(argp1);
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 delete arg1;
11008
11009 wxPyEndAllowThreads(__tstate);
11010 if (PyErr_Occurred()) SWIG_fail;
11011 }
11012 resultobj = SWIG_Py_Void();
11013 return resultobj;
11014 fail:
11015 return NULL;
11016 }
11017
11018
11019 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11020 PyObject *resultobj = 0;
11021 bool result;
11022
11023 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11024 {
11025 PyThreadState* __tstate = wxPyBeginAllowThreads();
11026 result = (bool)wxLog::IsEnabled();
11027 wxPyEndAllowThreads(__tstate);
11028 if (PyErr_Occurred()) SWIG_fail;
11029 }
11030 {
11031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11032 }
11033 return resultobj;
11034 fail:
11035 return NULL;
11036 }
11037
11038
11039 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11040 PyObject *resultobj = 0;
11041 bool arg1 = (bool) true ;
11042 bool result;
11043 bool val1 ;
11044 int ecode1 = 0 ;
11045 PyObject * obj0 = 0 ;
11046 char * kwnames[] = {
11047 (char *) "doIt", NULL
11048 };
11049
11050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11051 if (obj0) {
11052 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11053 if (!SWIG_IsOK(ecode1)) {
11054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11055 }
11056 arg1 = static_cast< bool >(val1);
11057 }
11058 {
11059 PyThreadState* __tstate = wxPyBeginAllowThreads();
11060 result = (bool)wxLog::EnableLogging(arg1);
11061 wxPyEndAllowThreads(__tstate);
11062 if (PyErr_Occurred()) SWIG_fail;
11063 }
11064 {
11065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj = 0;
11075 wxLogLevel arg1 ;
11076 wxChar *arg2 = (wxChar *) 0 ;
11077 time_t arg3 ;
11078 unsigned long val1 ;
11079 int ecode1 = 0 ;
11080 void *argp2 = 0 ;
11081 int res2 = 0 ;
11082 unsigned int val3 ;
11083 int ecode3 = 0 ;
11084 PyObject * obj0 = 0 ;
11085 PyObject * obj1 = 0 ;
11086 PyObject * obj2 = 0 ;
11087 char * kwnames[] = {
11088 (char *) "level",(char *) "szString",(char *) "t", NULL
11089 };
11090
11091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11092 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11093 if (!SWIG_IsOK(ecode1)) {
11094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11095 }
11096 arg1 = static_cast< wxLogLevel >(val1);
11097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11098 if (!SWIG_IsOK(res2)) {
11099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11100 }
11101 arg2 = reinterpret_cast< wxChar * >(argp2);
11102 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11103 if (!SWIG_IsOK(ecode3)) {
11104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11105 }
11106 arg3 = static_cast< time_t >(val3);
11107 {
11108 PyThreadState* __tstate = wxPyBeginAllowThreads();
11109 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11110 wxPyEndAllowThreads(__tstate);
11111 if (PyErr_Occurred()) SWIG_fail;
11112 }
11113 resultobj = SWIG_Py_Void();
11114 return resultobj;
11115 fail:
11116 return NULL;
11117 }
11118
11119
11120 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11121 PyObject *resultobj = 0;
11122 wxLog *arg1 = (wxLog *) 0 ;
11123 void *argp1 = 0 ;
11124 int res1 = 0 ;
11125 PyObject *swig_obj[1] ;
11126
11127 if (!args) SWIG_fail;
11128 swig_obj[0] = args;
11129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11132 }
11133 arg1 = reinterpret_cast< wxLog * >(argp1);
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 (arg1)->Flush();
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 resultobj = SWIG_Py_Void();
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149
11150 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11151 {
11152 PyThreadState* __tstate = wxPyBeginAllowThreads();
11153 wxLog::FlushActive();
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 resultobj = SWIG_Py_Void();
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11165 PyObject *resultobj = 0;
11166 wxLog *result = 0 ;
11167
11168 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (wxLog *)wxLog::GetActiveTarget();
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj = 0;
11184 wxLog *arg1 = (wxLog *) 0 ;
11185 wxLog *result = 0 ;
11186 int res1 = 0 ;
11187 PyObject * obj0 = 0 ;
11188 char * kwnames[] = {
11189 (char *) "pLogger", NULL
11190 };
11191
11192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11193 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11194 if (!SWIG_IsOK(res1)) {
11195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11196 }
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11200 wxPyEndAllowThreads(__tstate);
11201 if (PyErr_Occurred()) SWIG_fail;
11202 }
11203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11204 return resultobj;
11205 fail:
11206 return NULL;
11207 }
11208
11209
11210 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11211 PyObject *resultobj = 0;
11212
11213 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 wxLog::Suspend();
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 resultobj = SWIG_Py_Void();
11221 return resultobj;
11222 fail:
11223 return NULL;
11224 }
11225
11226
11227 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11228 PyObject *resultobj = 0;
11229
11230 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 wxLog::Resume();
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 resultobj = SWIG_Py_Void();
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj = 0;
11246 bool arg1 = (bool) true ;
11247 bool val1 ;
11248 int ecode1 = 0 ;
11249 PyObject * obj0 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "bVerbose", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11255 if (obj0) {
11256 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11257 if (!SWIG_IsOK(ecode1)) {
11258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11259 }
11260 arg1 = static_cast< bool >(val1);
11261 }
11262 {
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 wxLog::SetVerbose(arg1);
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 resultobj = SWIG_Py_Void();
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj = 0;
11277 wxLogLevel arg1 ;
11278 unsigned long val1 ;
11279 int ecode1 = 0 ;
11280 PyObject * obj0 = 0 ;
11281 char * kwnames[] = {
11282 (char *) "logLevel", NULL
11283 };
11284
11285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11286 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11287 if (!SWIG_IsOK(ecode1)) {
11288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11289 }
11290 arg1 = static_cast< wxLogLevel >(val1);
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 wxLog::SetLogLevel(arg1);
11294 wxPyEndAllowThreads(__tstate);
11295 if (PyErr_Occurred()) SWIG_fail;
11296 }
11297 resultobj = SWIG_Py_Void();
11298 return resultobj;
11299 fail:
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 PyObject *resultobj = 0;
11306
11307 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11308 {
11309 PyThreadState* __tstate = wxPyBeginAllowThreads();
11310 wxLog::DontCreateOnDemand();
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 resultobj = SWIG_Py_Void();
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj = 0;
11323 wxTraceMask arg1 ;
11324 unsigned long val1 ;
11325 int ecode1 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 char * kwnames[] = {
11328 (char *) "ulMask", NULL
11329 };
11330
11331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11332 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11333 if (!SWIG_IsOK(ecode1)) {
11334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11335 }
11336 arg1 = static_cast< wxTraceMask >(val1);
11337 {
11338 PyThreadState* __tstate = wxPyBeginAllowThreads();
11339 wxLog::SetTraceMask(arg1);
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 resultobj = SWIG_Py_Void();
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj = 0;
11352 wxString *arg1 = 0 ;
11353 bool temp1 = false ;
11354 PyObject * obj0 = 0 ;
11355 char * kwnames[] = {
11356 (char *) "str", NULL
11357 };
11358
11359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11360 {
11361 arg1 = wxString_in_helper(obj0);
11362 if (arg1 == NULL) SWIG_fail;
11363 temp1 = true;
11364 }
11365 {
11366 PyThreadState* __tstate = wxPyBeginAllowThreads();
11367 wxLog::AddTraceMask((wxString const &)*arg1);
11368 wxPyEndAllowThreads(__tstate);
11369 if (PyErr_Occurred()) SWIG_fail;
11370 }
11371 resultobj = SWIG_Py_Void();
11372 {
11373 if (temp1)
11374 delete arg1;
11375 }
11376 return resultobj;
11377 fail:
11378 {
11379 if (temp1)
11380 delete arg1;
11381 }
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11387 PyObject *resultobj = 0;
11388 wxString *arg1 = 0 ;
11389 bool temp1 = false ;
11390 PyObject * obj0 = 0 ;
11391 char * kwnames[] = {
11392 (char *) "str", NULL
11393 };
11394
11395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11396 {
11397 arg1 = wxString_in_helper(obj0);
11398 if (arg1 == NULL) SWIG_fail;
11399 temp1 = true;
11400 }
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 wxLog::RemoveTraceMask((wxString const &)*arg1);
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 resultobj = SWIG_Py_Void();
11408 {
11409 if (temp1)
11410 delete arg1;
11411 }
11412 return resultobj;
11413 fail:
11414 {
11415 if (temp1)
11416 delete arg1;
11417 }
11418 return NULL;
11419 }
11420
11421
11422 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423 PyObject *resultobj = 0;
11424
11425 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11426 {
11427 PyThreadState* __tstate = wxPyBeginAllowThreads();
11428 wxLog::ClearTraceMasks();
11429 wxPyEndAllowThreads(__tstate);
11430 if (PyErr_Occurred()) SWIG_fail;
11431 }
11432 resultobj = SWIG_Py_Void();
11433 return resultobj;
11434 fail:
11435 return NULL;
11436 }
11437
11438
11439 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11440 PyObject *resultobj = 0;
11441 wxArrayString *result = 0 ;
11442
11443 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 {
11447 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11448 result = (wxArrayString *) &_result_ref;
11449 }
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 {
11454 resultobj = wxArrayString2PyList_helper(*result);
11455 }
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj = 0;
11464 wxChar *arg1 = (wxChar *) 0 ;
11465 void *argp1 = 0 ;
11466 int res1 = 0 ;
11467 PyObject * obj0 = 0 ;
11468 char * kwnames[] = {
11469 (char *) "ts", NULL
11470 };
11471
11472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11474 if (!SWIG_IsOK(res1)) {
11475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11476 }
11477 arg1 = reinterpret_cast< wxChar * >(argp1);
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 wxLog::SetTimestamp((wxChar const *)arg1);
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 resultobj = SWIG_Py_Void();
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11492 PyObject *resultobj = 0;
11493 bool result;
11494
11495 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (bool)wxLog::GetVerbose();
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11504 }
11505 return resultobj;
11506 fail:
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11512 PyObject *resultobj = 0;
11513 wxTraceMask result;
11514
11515 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 result = (wxTraceMask)wxLog::GetTraceMask();
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxChar *arg1 = (wxChar *) 0 ;
11532 bool result;
11533 void *argp1 = 0 ;
11534 int res1 = 0 ;
11535 PyObject * obj0 = 0 ;
11536 char * kwnames[] = {
11537 (char *) "mask", NULL
11538 };
11539
11540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11542 if (!SWIG_IsOK(res1)) {
11543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11544 }
11545 arg1 = reinterpret_cast< wxChar * >(argp1);
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11562 PyObject *resultobj = 0;
11563 wxLogLevel result;
11564
11565 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11566 {
11567 PyThreadState* __tstate = wxPyBeginAllowThreads();
11568 result = (wxLogLevel)wxLog::GetLogLevel();
11569 wxPyEndAllowThreads(__tstate);
11570 if (PyErr_Occurred()) SWIG_fail;
11571 }
11572 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11573 return resultobj;
11574 fail:
11575 return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11580 PyObject *resultobj = 0;
11581 wxChar *result = 0 ;
11582
11583 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11584 {
11585 PyThreadState* __tstate = wxPyBeginAllowThreads();
11586 result = (wxChar *)wxLog::GetTimestamp();
11587 wxPyEndAllowThreads(__tstate);
11588 if (PyErr_Occurred()) SWIG_fail;
11589 }
11590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11598 PyObject *resultobj = 0;
11599 wxString result;
11600
11601 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 result = wxLog_TimeStamp();
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 #if wxUSE_UNICODE
11610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11611 #else
11612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11613 #endif
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11622 PyObject *resultobj = 0;
11623 wxLog *arg1 = (wxLog *) 0 ;
11624 void *argp1 = 0 ;
11625 int res1 = 0 ;
11626 PyObject *swig_obj[1] ;
11627
11628 if (!args) SWIG_fail;
11629 swig_obj[0] = args;
11630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11631 if (!SWIG_IsOK(res1)) {
11632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11633 }
11634 arg1 = reinterpret_cast< wxLog * >(argp1);
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 wxLog_Destroy(arg1);
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 resultobj = SWIG_Py_Void();
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649 PyObject *obj;
11650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11651 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11652 return SWIG_Py_Void();
11653 }
11654
11655 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 return SWIG_Python_InitShadowInstance(args);
11657 }
11658
11659 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11660 PyObject *resultobj = 0;
11661 wxLogStderr *result = 0 ;
11662
11663 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (wxLogStderr *)new wxLogStderr();
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 PyObject *obj;
11679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11680 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11681 return SWIG_Py_Void();
11682 }
11683
11684 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11685 return SWIG_Python_InitShadowInstance(args);
11686 }
11687
11688 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11691 wxLogTextCtrl *result = 0 ;
11692 void *argp1 = 0 ;
11693 int res1 = 0 ;
11694 PyObject * obj0 = 0 ;
11695 char * kwnames[] = {
11696 (char *) "pTextCtrl", NULL
11697 };
11698
11699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11703 }
11704 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *obj;
11720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11721 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11722 return SWIG_Py_Void();
11723 }
11724
11725 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11726 return SWIG_Python_InitShadowInstance(args);
11727 }
11728
11729 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 PyObject *resultobj = 0;
11731 wxLogGui *result = 0 ;
11732
11733 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11734 {
11735 PyThreadState* __tstate = wxPyBeginAllowThreads();
11736 result = (wxLogGui *)new wxLogGui();
11737 wxPyEndAllowThreads(__tstate);
11738 if (PyErr_Occurred()) SWIG_fail;
11739 }
11740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11748 PyObject *obj;
11749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11750 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11751 return SWIG_Py_Void();
11752 }
11753
11754 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11755 return SWIG_Python_InitShadowInstance(args);
11756 }
11757
11758 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11759 PyObject *resultobj = 0;
11760 wxFrame *arg1 = (wxFrame *) 0 ;
11761 wxString *arg2 = 0 ;
11762 bool arg3 = (bool) true ;
11763 bool arg4 = (bool) true ;
11764 wxLogWindow *result = 0 ;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 bool temp2 = false ;
11768 bool val3 ;
11769 int ecode3 = 0 ;
11770 bool val4 ;
11771 int ecode4 = 0 ;
11772 PyObject * obj0 = 0 ;
11773 PyObject * obj1 = 0 ;
11774 PyObject * obj2 = 0 ;
11775 PyObject * obj3 = 0 ;
11776 char * kwnames[] = {
11777 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11778 };
11779
11780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11784 }
11785 arg1 = reinterpret_cast< wxFrame * >(argp1);
11786 {
11787 arg2 = wxString_in_helper(obj1);
11788 if (arg2 == NULL) SWIG_fail;
11789 temp2 = true;
11790 }
11791 if (obj2) {
11792 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11793 if (!SWIG_IsOK(ecode3)) {
11794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11795 }
11796 arg3 = static_cast< bool >(val3);
11797 }
11798 if (obj3) {
11799 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11800 if (!SWIG_IsOK(ecode4)) {
11801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11802 }
11803 arg4 = static_cast< bool >(val4);
11804 }
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11812 {
11813 if (temp2)
11814 delete arg2;
11815 }
11816 return resultobj;
11817 fail:
11818 {
11819 if (temp2)
11820 delete arg2;
11821 }
11822 return NULL;
11823 }
11824
11825
11826 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj = 0;
11828 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11829 bool arg2 = (bool) true ;
11830 void *argp1 = 0 ;
11831 int res1 = 0 ;
11832 bool val2 ;
11833 int ecode2 = 0 ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 char * kwnames[] = {
11837 (char *) "self",(char *) "bShow", NULL
11838 };
11839
11840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11842 if (!SWIG_IsOK(res1)) {
11843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11844 }
11845 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11846 if (obj1) {
11847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11848 if (!SWIG_IsOK(ecode2)) {
11849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11850 }
11851 arg2 = static_cast< bool >(val2);
11852 }
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 (arg1)->Show(arg2);
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 resultobj = SWIG_Py_Void();
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11867 PyObject *resultobj = 0;
11868 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11869 wxFrame *result = 0 ;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 PyObject *swig_obj[1] ;
11873
11874 if (!args) SWIG_fail;
11875 swig_obj[0] = args;
11876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11877 if (!SWIG_IsOK(res1)) {
11878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11879 }
11880 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = wxPyMake_wxObject(result, (bool)0);
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11897 PyObject *resultobj = 0;
11898 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11899 wxLog *result = 0 ;
11900 void *argp1 = 0 ;
11901 int res1 = 0 ;
11902 PyObject *swig_obj[1] ;
11903
11904 if (!args) SWIG_fail;
11905 swig_obj[0] = args;
11906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11907 if (!SWIG_IsOK(res1)) {
11908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11909 }
11910 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11925 PyObject *resultobj = 0;
11926 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11927 bool result;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 PyObject *swig_obj[1] ;
11931
11932 if (!args) SWIG_fail;
11933 swig_obj[0] = args;
11934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11935 if (!SWIG_IsOK(res1)) {
11936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11937 }
11938 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 {
11946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11947 }
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj = 0;
11956 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11957 bool arg2 ;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 bool val2 ;
11961 int ecode2 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 char * kwnames[] = {
11965 (char *) "self",(char *) "bDoPass", NULL
11966 };
11967
11968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11970 if (!SWIG_IsOK(res1)) {
11971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11972 }
11973 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11975 if (!SWIG_IsOK(ecode2)) {
11976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11977 }
11978 arg2 = static_cast< bool >(val2);
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 (arg1)->PassMessages(arg2);
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 resultobj = SWIG_Py_Void();
11986 return resultobj;
11987 fail:
11988 return NULL;
11989 }
11990
11991
11992 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11993 PyObject *obj;
11994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11995 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11996 return SWIG_Py_Void();
11997 }
11998
11999 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12000 return SWIG_Python_InitShadowInstance(args);
12001 }
12002
12003 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj = 0;
12005 wxLog *arg1 = (wxLog *) 0 ;
12006 wxLogChain *result = 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 PyObject * obj0 = 0 ;
12010 char * kwnames[] = {
12011 (char *) "logger", NULL
12012 };
12013
12014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12016 if (!SWIG_IsOK(res1)) {
12017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12018 }
12019 arg1 = reinterpret_cast< wxLog * >(argp1);
12020 {
12021 PyThreadState* __tstate = wxPyBeginAllowThreads();
12022 result = (wxLogChain *)new wxLogChain(arg1);
12023 wxPyEndAllowThreads(__tstate);
12024 if (PyErr_Occurred()) SWIG_fail;
12025 }
12026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12027 return resultobj;
12028 fail:
12029 return NULL;
12030 }
12031
12032
12033 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12034 PyObject *resultobj = 0;
12035 wxLogChain *arg1 = (wxLogChain *) 0 ;
12036 wxLog *arg2 = (wxLog *) 0 ;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 void *argp2 = 0 ;
12040 int res2 = 0 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "self",(char *) "logger", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12051 }
12052 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12054 if (!SWIG_IsOK(res2)) {
12055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12056 }
12057 arg2 = reinterpret_cast< wxLog * >(argp2);
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 (arg1)->SetLog(arg2);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_Py_Void();
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj = 0;
12073 wxLogChain *arg1 = (wxLogChain *) 0 ;
12074 bool arg2 ;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 bool val2 ;
12078 int ecode2 = 0 ;
12079 PyObject * obj0 = 0 ;
12080 PyObject * obj1 = 0 ;
12081 char * kwnames[] = {
12082 (char *) "self",(char *) "bDoPass", NULL
12083 };
12084
12085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12089 }
12090 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12091 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12092 if (!SWIG_IsOK(ecode2)) {
12093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12094 }
12095 arg2 = static_cast< bool >(val2);
12096 {
12097 PyThreadState* __tstate = wxPyBeginAllowThreads();
12098 (arg1)->PassMessages(arg2);
12099 wxPyEndAllowThreads(__tstate);
12100 if (PyErr_Occurred()) SWIG_fail;
12101 }
12102 resultobj = SWIG_Py_Void();
12103 return resultobj;
12104 fail:
12105 return NULL;
12106 }
12107
12108
12109 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12110 PyObject *resultobj = 0;
12111 wxLogChain *arg1 = (wxLogChain *) 0 ;
12112 bool result;
12113 void *argp1 = 0 ;
12114 int res1 = 0 ;
12115 PyObject *swig_obj[1] ;
12116
12117 if (!args) SWIG_fail;
12118 swig_obj[0] = args;
12119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12120 if (!SWIG_IsOK(res1)) {
12121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12122 }
12123 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 result = (bool)(arg1)->IsPassingMessages();
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 {
12131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12132 }
12133 return resultobj;
12134 fail:
12135 return NULL;
12136 }
12137
12138
12139 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12140 PyObject *resultobj = 0;
12141 wxLogChain *arg1 = (wxLogChain *) 0 ;
12142 wxLog *result = 0 ;
12143 void *argp1 = 0 ;
12144 int res1 = 0 ;
12145 PyObject *swig_obj[1] ;
12146
12147 if (!args) SWIG_fail;
12148 swig_obj[0] = args;
12149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12150 if (!SWIG_IsOK(res1)) {
12151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12152 }
12153 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (wxLog *)(arg1)->GetOldLog();
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12168 PyObject *obj;
12169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12170 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12171 return SWIG_Py_Void();
12172 }
12173
12174 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 return SWIG_Python_InitShadowInstance(args);
12176 }
12177
12178 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179 PyObject *resultobj = 0;
12180 wxLogBuffer *result = 0 ;
12181
12182 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (wxLogBuffer *)new wxLogBuffer();
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12190 return resultobj;
12191 fail:
12192 return NULL;
12193 }
12194
12195
12196 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12197 PyObject *resultobj = 0;
12198 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12199 wxString *result = 0 ;
12200 void *argp1 = 0 ;
12201 int res1 = 0 ;
12202 PyObject *swig_obj[1] ;
12203
12204 if (!args) SWIG_fail;
12205 swig_obj[0] = args;
12206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12207 if (!SWIG_IsOK(res1)) {
12208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12209 }
12210 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 {
12214 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12215 result = (wxString *) &_result_ref;
12216 }
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 {
12221 #if wxUSE_UNICODE
12222 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12223 #else
12224 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12225 #endif
12226 }
12227 return resultobj;
12228 fail:
12229 return NULL;
12230 }
12231
12232
12233 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12234 PyObject *obj;
12235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12236 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12237 return SWIG_Py_Void();
12238 }
12239
12240 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12241 return SWIG_Python_InitShadowInstance(args);
12242 }
12243
12244 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12245 PyObject *resultobj = 0;
12246 unsigned long result;
12247
12248 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (unsigned long)wxSysErrorCode();
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 unsigned long arg1 = (unsigned long) 0 ;
12265 wxString result;
12266 unsigned long val1 ;
12267 int ecode1 = 0 ;
12268 PyObject * obj0 = 0 ;
12269 char * kwnames[] = {
12270 (char *) "nErrCode", NULL
12271 };
12272
12273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12274 if (obj0) {
12275 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12276 if (!SWIG_IsOK(ecode1)) {
12277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12278 }
12279 arg1 = static_cast< unsigned long >(val1);
12280 }
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 result = wxSysErrorMsg(arg1);
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 {
12288 #if wxUSE_UNICODE
12289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12290 #else
12291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12292 #endif
12293 }
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = 0;
12302 wxString *arg1 = 0 ;
12303 bool temp1 = false ;
12304 PyObject * obj0 = 0 ;
12305 char * kwnames[] = {
12306 (char *) "msg", NULL
12307 };
12308
12309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12310 {
12311 arg1 = wxString_in_helper(obj0);
12312 if (arg1 == NULL) SWIG_fail;
12313 temp1 = true;
12314 }
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 wxPyLogFatalError((wxString const &)*arg1);
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 resultobj = SWIG_Py_Void();
12322 {
12323 if (temp1)
12324 delete arg1;
12325 }
12326 return resultobj;
12327 fail:
12328 {
12329 if (temp1)
12330 delete arg1;
12331 }
12332 return NULL;
12333 }
12334
12335
12336 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj = 0;
12338 wxString *arg1 = 0 ;
12339 bool temp1 = false ;
12340 PyObject * obj0 = 0 ;
12341 char * kwnames[] = {
12342 (char *) "msg", NULL
12343 };
12344
12345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12346 {
12347 arg1 = wxString_in_helper(obj0);
12348 if (arg1 == NULL) SWIG_fail;
12349 temp1 = true;
12350 }
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 wxPyLogError((wxString const &)*arg1);
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 resultobj = SWIG_Py_Void();
12358 {
12359 if (temp1)
12360 delete arg1;
12361 }
12362 return resultobj;
12363 fail:
12364 {
12365 if (temp1)
12366 delete arg1;
12367 }
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj = 0;
12374 wxString *arg1 = 0 ;
12375 bool temp1 = false ;
12376 PyObject * obj0 = 0 ;
12377 char * kwnames[] = {
12378 (char *) "msg", NULL
12379 };
12380
12381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12382 {
12383 arg1 = wxString_in_helper(obj0);
12384 if (arg1 == NULL) SWIG_fail;
12385 temp1 = true;
12386 }
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 wxPyLogWarning((wxString const &)*arg1);
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 resultobj = SWIG_Py_Void();
12394 {
12395 if (temp1)
12396 delete arg1;
12397 }
12398 return resultobj;
12399 fail:
12400 {
12401 if (temp1)
12402 delete arg1;
12403 }
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12409 PyObject *resultobj = 0;
12410 wxString *arg1 = 0 ;
12411 bool temp1 = false ;
12412 PyObject * obj0 = 0 ;
12413 char * kwnames[] = {
12414 (char *) "msg", NULL
12415 };
12416
12417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12418 {
12419 arg1 = wxString_in_helper(obj0);
12420 if (arg1 == NULL) SWIG_fail;
12421 temp1 = true;
12422 }
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 wxPyLogMessage((wxString const &)*arg1);
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_Py_Void();
12430 {
12431 if (temp1)
12432 delete arg1;
12433 }
12434 return resultobj;
12435 fail:
12436 {
12437 if (temp1)
12438 delete arg1;
12439 }
12440 return NULL;
12441 }
12442
12443
12444 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12445 PyObject *resultobj = 0;
12446 wxString *arg1 = 0 ;
12447 bool temp1 = false ;
12448 PyObject * obj0 = 0 ;
12449 char * kwnames[] = {
12450 (char *) "msg", NULL
12451 };
12452
12453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12454 {
12455 arg1 = wxString_in_helper(obj0);
12456 if (arg1 == NULL) SWIG_fail;
12457 temp1 = true;
12458 }
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 wxPyLogInfo((wxString const &)*arg1);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_Py_Void();
12466 {
12467 if (temp1)
12468 delete arg1;
12469 }
12470 return resultobj;
12471 fail:
12472 {
12473 if (temp1)
12474 delete arg1;
12475 }
12476 return NULL;
12477 }
12478
12479
12480 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj = 0;
12482 wxString *arg1 = 0 ;
12483 bool temp1 = false ;
12484 PyObject * obj0 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "msg", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12490 {
12491 arg1 = wxString_in_helper(obj0);
12492 if (arg1 == NULL) SWIG_fail;
12493 temp1 = true;
12494 }
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 wxPyLogDebug((wxString const &)*arg1);
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_Py_Void();
12502 {
12503 if (temp1)
12504 delete arg1;
12505 }
12506 return resultobj;
12507 fail:
12508 {
12509 if (temp1)
12510 delete arg1;
12511 }
12512 return NULL;
12513 }
12514
12515
12516 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj = 0;
12518 wxString *arg1 = 0 ;
12519 bool temp1 = false ;
12520 PyObject * obj0 = 0 ;
12521 char * kwnames[] = {
12522 (char *) "msg", NULL
12523 };
12524
12525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12526 {
12527 arg1 = wxString_in_helper(obj0);
12528 if (arg1 == NULL) SWIG_fail;
12529 temp1 = true;
12530 }
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 wxPyLogVerbose((wxString const &)*arg1);
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 resultobj = SWIG_Py_Void();
12538 {
12539 if (temp1)
12540 delete arg1;
12541 }
12542 return resultobj;
12543 fail:
12544 {
12545 if (temp1)
12546 delete arg1;
12547 }
12548 return NULL;
12549 }
12550
12551
12552 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj = 0;
12554 wxString *arg1 = 0 ;
12555 bool temp1 = false ;
12556 PyObject * obj0 = 0 ;
12557 char * kwnames[] = {
12558 (char *) "msg", NULL
12559 };
12560
12561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12562 {
12563 arg1 = wxString_in_helper(obj0);
12564 if (arg1 == NULL) SWIG_fail;
12565 temp1 = true;
12566 }
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 wxPyLogStatus((wxString const &)*arg1);
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 resultobj = SWIG_Py_Void();
12574 {
12575 if (temp1)
12576 delete arg1;
12577 }
12578 return resultobj;
12579 fail:
12580 {
12581 if (temp1)
12582 delete arg1;
12583 }
12584 return NULL;
12585 }
12586
12587
12588 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj = 0;
12590 wxFrame *arg1 = (wxFrame *) 0 ;
12591 wxString *arg2 = 0 ;
12592 void *argp1 = 0 ;
12593 int res1 = 0 ;
12594 bool temp2 = false ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "pFrame",(char *) "msg", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12605 }
12606 arg1 = reinterpret_cast< wxFrame * >(argp1);
12607 {
12608 arg2 = wxString_in_helper(obj1);
12609 if (arg2 == NULL) SWIG_fail;
12610 temp2 = true;
12611 }
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12615 wxPyEndAllowThreads(__tstate);
12616 if (PyErr_Occurred()) SWIG_fail;
12617 }
12618 resultobj = SWIG_Py_Void();
12619 {
12620 if (temp2)
12621 delete arg2;
12622 }
12623 return resultobj;
12624 fail:
12625 {
12626 if (temp2)
12627 delete arg2;
12628 }
12629 return NULL;
12630 }
12631
12632
12633 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12634 PyObject *resultobj = 0;
12635 wxString *arg1 = 0 ;
12636 bool temp1 = false ;
12637 PyObject * obj0 = 0 ;
12638 char * kwnames[] = {
12639 (char *) "msg", NULL
12640 };
12641
12642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12643 {
12644 arg1 = wxString_in_helper(obj0);
12645 if (arg1 == NULL) SWIG_fail;
12646 temp1 = true;
12647 }
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 wxPyLogSysError((wxString const &)*arg1);
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 resultobj = SWIG_Py_Void();
12655 {
12656 if (temp1)
12657 delete arg1;
12658 }
12659 return resultobj;
12660 fail:
12661 {
12662 if (temp1)
12663 delete arg1;
12664 }
12665 return NULL;
12666 }
12667
12668
12669 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12670 PyObject *resultobj = 0;
12671 unsigned long arg1 ;
12672 wxString *arg2 = 0 ;
12673 unsigned long val1 ;
12674 int ecode1 = 0 ;
12675 bool temp2 = false ;
12676 PyObject * obj0 = 0 ;
12677 PyObject * obj1 = 0 ;
12678 char * kwnames[] = {
12679 (char *) "level",(char *) "msg", NULL
12680 };
12681
12682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12683 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12684 if (!SWIG_IsOK(ecode1)) {
12685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12686 }
12687 arg1 = static_cast< unsigned long >(val1);
12688 {
12689 arg2 = wxString_in_helper(obj1);
12690 if (arg2 == NULL) SWIG_fail;
12691 temp2 = true;
12692 }
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 resultobj = SWIG_Py_Void();
12700 {
12701 if (temp2)
12702 delete arg2;
12703 }
12704 return resultobj;
12705 fail:
12706 {
12707 if (temp2)
12708 delete arg2;
12709 }
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12715 PyObject *resultobj = 0;
12716 unsigned long arg1 ;
12717 wxString *arg2 = 0 ;
12718 unsigned long val1 ;
12719 int ecode1 = 0 ;
12720 bool temp2 = false ;
12721
12722 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12723 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12724 if (!SWIG_IsOK(ecode1)) {
12725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12726 }
12727 arg1 = static_cast< unsigned long >(val1);
12728 {
12729 arg2 = wxString_in_helper(swig_obj[1]);
12730 if (arg2 == NULL) SWIG_fail;
12731 temp2 = true;
12732 }
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 wxPyLogTrace(arg1,(wxString const &)*arg2);
12736 wxPyEndAllowThreads(__tstate);
12737 if (PyErr_Occurred()) SWIG_fail;
12738 }
12739 resultobj = SWIG_Py_Void();
12740 {
12741 if (temp2)
12742 delete arg2;
12743 }
12744 return resultobj;
12745 fail:
12746 {
12747 if (temp2)
12748 delete arg2;
12749 }
12750 return NULL;
12751 }
12752
12753
12754 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12755 PyObject *resultobj = 0;
12756 wxString *arg1 = 0 ;
12757 wxString *arg2 = 0 ;
12758 bool temp1 = false ;
12759 bool temp2 = false ;
12760
12761 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12762 {
12763 arg1 = wxString_in_helper(swig_obj[0]);
12764 if (arg1 == NULL) SWIG_fail;
12765 temp1 = true;
12766 }
12767 {
12768 arg2 = wxString_in_helper(swig_obj[1]);
12769 if (arg2 == NULL) SWIG_fail;
12770 temp2 = true;
12771 }
12772 {
12773 PyThreadState* __tstate = wxPyBeginAllowThreads();
12774 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12775 wxPyEndAllowThreads(__tstate);
12776 if (PyErr_Occurred()) SWIG_fail;
12777 }
12778 resultobj = SWIG_Py_Void();
12779 {
12780 if (temp1)
12781 delete arg1;
12782 }
12783 {
12784 if (temp2)
12785 delete arg2;
12786 }
12787 return resultobj;
12788 fail:
12789 {
12790 if (temp1)
12791 delete arg1;
12792 }
12793 {
12794 if (temp2)
12795 delete arg2;
12796 }
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12802 int argc;
12803 PyObject *argv[3];
12804
12805 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12806 --argc;
12807 if (argc == 2) {
12808 int _v = 0;
12809 {
12810 {
12811 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12812 }
12813 }
12814 if (!_v) goto check_1;
12815 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12816 }
12817 check_1:
12818
12819 if (argc == 2) {
12820 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12821 }
12822
12823 fail:
12824 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj = 0;
12831 wxString *arg1 = 0 ;
12832 wxString *arg2 = 0 ;
12833 bool temp1 = false ;
12834 bool temp2 = false ;
12835 PyObject * obj0 = 0 ;
12836 PyObject * obj1 = 0 ;
12837 char * kwnames[] = {
12838 (char *) "title",(char *) "text", NULL
12839 };
12840
12841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12842 {
12843 arg1 = wxString_in_helper(obj0);
12844 if (arg1 == NULL) SWIG_fail;
12845 temp1 = true;
12846 }
12847 {
12848 arg2 = wxString_in_helper(obj1);
12849 if (arg2 == NULL) SWIG_fail;
12850 temp2 = true;
12851 }
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 resultobj = SWIG_Py_Void();
12859 {
12860 if (temp1)
12861 delete arg1;
12862 }
12863 {
12864 if (temp2)
12865 delete arg2;
12866 }
12867 return resultobj;
12868 fail:
12869 {
12870 if (temp1)
12871 delete arg1;
12872 }
12873 {
12874 if (temp2)
12875 delete arg2;
12876 }
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *resultobj = 0;
12883 wxLogNull *result = 0 ;
12884
12885 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12886 {
12887 PyThreadState* __tstate = wxPyBeginAllowThreads();
12888 result = (wxLogNull *)new wxLogNull();
12889 wxPyEndAllowThreads(__tstate);
12890 if (PyErr_Occurred()) SWIG_fail;
12891 }
12892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12900 PyObject *resultobj = 0;
12901 wxLogNull *arg1 = (wxLogNull *) 0 ;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 PyObject *swig_obj[1] ;
12905
12906 if (!args) SWIG_fail;
12907 swig_obj[0] = args;
12908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12909 if (!SWIG_IsOK(res1)) {
12910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12911 }
12912 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12913 {
12914 PyThreadState* __tstate = wxPyBeginAllowThreads();
12915 delete arg1;
12916
12917 wxPyEndAllowThreads(__tstate);
12918 if (PyErr_Occurred()) SWIG_fail;
12919 }
12920 resultobj = SWIG_Py_Void();
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *obj;
12929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12930 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12931 return SWIG_Py_Void();
12932 }
12933
12934 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12935 return SWIG_Python_InitShadowInstance(args);
12936 }
12937
12938 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxPyLog *result = 0 ;
12941
12942 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 result = (wxPyLog *)new wxPyLog();
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12957 PyObject *resultobj = 0;
12958 wxPyLog *arg1 = (wxPyLog *) 0 ;
12959 PyObject *arg2 = (PyObject *) 0 ;
12960 PyObject *arg3 = (PyObject *) 0 ;
12961 void *argp1 = 0 ;
12962 int res1 = 0 ;
12963 PyObject * obj0 = 0 ;
12964 PyObject * obj1 = 0 ;
12965 PyObject * obj2 = 0 ;
12966 char * kwnames[] = {
12967 (char *) "self",(char *) "self",(char *) "_class", NULL
12968 };
12969
12970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12974 }
12975 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12976 arg2 = obj1;
12977 arg3 = obj2;
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 (arg1)->_setCallbackInfo(arg2,arg3);
12981 wxPyEndAllowThreads(__tstate);
12982 if (PyErr_Occurred()) SWIG_fail;
12983 }
12984 resultobj = SWIG_Py_Void();
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 PyObject *obj;
12993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12994 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12995 return SWIG_Py_Void();
12996 }
12997
12998 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999 return SWIG_Python_InitShadowInstance(args);
13000 }
13001
13002 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj = 0;
13004 int arg1 ;
13005 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13006 int arg3 = (int) wxKILL_NOCHILDREN ;
13007 wxKillError result;
13008 int val1 ;
13009 int ecode1 = 0 ;
13010 int val2 ;
13011 int ecode2 = 0 ;
13012 int val3 ;
13013 int ecode3 = 0 ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 PyObject * obj2 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13022 ecode1 = SWIG_AsVal_int(obj0, &val1);
13023 if (!SWIG_IsOK(ecode1)) {
13024 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13025 }
13026 arg1 = static_cast< int >(val1);
13027 if (obj1) {
13028 ecode2 = SWIG_AsVal_int(obj1, &val2);
13029 if (!SWIG_IsOK(ecode2)) {
13030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13031 }
13032 arg2 = static_cast< wxSignal >(val2);
13033 }
13034 if (obj2) {
13035 ecode3 = SWIG_AsVal_int(obj2, &val3);
13036 if (!SWIG_IsOK(ecode3)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13038 }
13039 arg3 = static_cast< int >(val3);
13040 }
13041 {
13042 PyThreadState* __tstate = wxPyBeginAllowThreads();
13043 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 resultobj = SWIG_From_int(static_cast< int >(result));
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 int arg1 ;
13057 bool result;
13058 int val1 ;
13059 int ecode1 = 0 ;
13060 PyObject * obj0 = 0 ;
13061 char * kwnames[] = {
13062 (char *) "pid", NULL
13063 };
13064
13065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13066 ecode1 = SWIG_AsVal_int(obj0, &val1);
13067 if (!SWIG_IsOK(ecode1)) {
13068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13069 }
13070 arg1 = static_cast< int >(val1);
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 result = (bool)wxPyProcess::Exists(arg1);
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 {
13078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13079 }
13080 return resultobj;
13081 fail:
13082 return NULL;
13083 }
13084
13085
13086 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13087 PyObject *resultobj = 0;
13088 wxString *arg1 = 0 ;
13089 int arg2 = (int) wxEXEC_ASYNC ;
13090 wxPyProcess *result = 0 ;
13091 bool temp1 = false ;
13092 int val2 ;
13093 int ecode2 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "cmd",(char *) "flags", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13101 {
13102 arg1 = wxString_in_helper(obj0);
13103 if (arg1 == NULL) SWIG_fail;
13104 temp1 = true;
13105 }
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_int(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13110 }
13111 arg2 = static_cast< int >(val2);
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13120 {
13121 if (temp1)
13122 delete arg1;
13123 }
13124 return resultobj;
13125 fail:
13126 {
13127 if (temp1)
13128 delete arg1;
13129 }
13130 return NULL;
13131 }
13132
13133
13134 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13135 PyObject *resultobj = 0;
13136 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13137 int arg2 = (int) -1 ;
13138 wxPyProcess *result = 0 ;
13139 void *argp1 = 0 ;
13140 int res1 = 0 ;
13141 int val2 ;
13142 int ecode2 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char * kwnames[] = {
13146 (char *) "parent",(char *) "id", NULL
13147 };
13148
13149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13150 if (obj0) {
13151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13152 if (!SWIG_IsOK(res1)) {
13153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13154 }
13155 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13156 }
13157 if (obj1) {
13158 ecode2 = SWIG_AsVal_int(obj1, &val2);
13159 if (!SWIG_IsOK(ecode2)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13161 }
13162 arg2 = static_cast< int >(val2);
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj = 0;
13179 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13180 PyObject *arg2 = (PyObject *) 0 ;
13181 PyObject *arg3 = (PyObject *) 0 ;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 PyObject * obj0 = 0 ;
13185 PyObject * obj1 = 0 ;
13186 PyObject * obj2 = 0 ;
13187 char * kwnames[] = {
13188 (char *) "self",(char *) "self",(char *) "_class", NULL
13189 };
13190
13191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13193 if (!SWIG_IsOK(res1)) {
13194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13195 }
13196 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13197 arg2 = obj1;
13198 arg3 = obj2;
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 (arg1)->_setCallbackInfo(arg2,arg3);
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 resultobj = SWIG_Py_Void();
13206 return resultobj;
13207 fail:
13208 return NULL;
13209 }
13210
13211
13212 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13213 PyObject *resultobj = 0;
13214 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13215 int arg2 ;
13216 int arg3 ;
13217 void *argp1 = 0 ;
13218 int res1 = 0 ;
13219 int val2 ;
13220 int ecode2 = 0 ;
13221 int val3 ;
13222 int ecode3 = 0 ;
13223 PyObject * obj0 = 0 ;
13224 PyObject * obj1 = 0 ;
13225 PyObject * obj2 = 0 ;
13226 char * kwnames[] = {
13227 (char *) "self",(char *) "pid",(char *) "status", NULL
13228 };
13229
13230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13232 if (!SWIG_IsOK(res1)) {
13233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13234 }
13235 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13236 ecode2 = SWIG_AsVal_int(obj1, &val2);
13237 if (!SWIG_IsOK(ecode2)) {
13238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13239 }
13240 arg2 = static_cast< int >(val2);
13241 ecode3 = SWIG_AsVal_int(obj2, &val3);
13242 if (!SWIG_IsOK(ecode3)) {
13243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13244 }
13245 arg3 = static_cast< int >(val3);
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 (arg1)->OnTerminate(arg2,arg3);
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 resultobj = SWIG_Py_Void();
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 PyObject *resultobj = 0;
13261 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 PyObject *swig_obj[1] ;
13265
13266 if (!args) SWIG_fail;
13267 swig_obj[0] = args;
13268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13271 }
13272 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 (arg1)->Redirect();
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 resultobj = SWIG_Py_Void();
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13287 PyObject *resultobj = 0;
13288 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13289 bool result;
13290 void *argp1 = 0 ;
13291 int res1 = 0 ;
13292 PyObject *swig_obj[1] ;
13293
13294 if (!args) SWIG_fail;
13295 swig_obj[0] = args;
13296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13297 if (!SWIG_IsOK(res1)) {
13298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13299 }
13300 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13301 {
13302 PyThreadState* __tstate = wxPyBeginAllowThreads();
13303 result = (bool)(arg1)->IsRedirected();
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 {
13308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13309 }
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13317 PyObject *resultobj = 0;
13318 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 PyObject *swig_obj[1] ;
13322
13323 if (!args) SWIG_fail;
13324 swig_obj[0] = args;
13325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13326 if (!SWIG_IsOK(res1)) {
13327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13328 }
13329 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 (arg1)->Detach();
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_Py_Void();
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13344 PyObject *resultobj = 0;
13345 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13346 wxInputStream *result = 0 ;
13347 void *argp1 = 0 ;
13348 int res1 = 0 ;
13349 PyObject *swig_obj[1] ;
13350
13351 if (!args) SWIG_fail;
13352 swig_obj[0] = args;
13353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13354 if (!SWIG_IsOK(res1)) {
13355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13356 }
13357 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (wxInputStream *)(arg1)->GetInputStream();
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 wxPyInputStream * _ptr = NULL;
13366
13367 if (result) {
13368 _ptr = new wxPyInputStream(result);
13369 }
13370 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13371 }
13372 return resultobj;
13373 fail:
13374 return NULL;
13375 }
13376
13377
13378 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13379 PyObject *resultobj = 0;
13380 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13381 wxInputStream *result = 0 ;
13382 void *argp1 = 0 ;
13383 int res1 = 0 ;
13384 PyObject *swig_obj[1] ;
13385
13386 if (!args) SWIG_fail;
13387 swig_obj[0] = args;
13388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13389 if (!SWIG_IsOK(res1)) {
13390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13391 }
13392 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 result = (wxInputStream *)(arg1)->GetErrorStream();
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 {
13400 wxPyInputStream * _ptr = NULL;
13401
13402 if (result) {
13403 _ptr = new wxPyInputStream(result);
13404 }
13405 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13406 }
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13414 PyObject *resultobj = 0;
13415 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13416 wxOutputStream *result = 0 ;
13417 void *argp1 = 0 ;
13418 int res1 = 0 ;
13419 PyObject *swig_obj[1] ;
13420
13421 if (!args) SWIG_fail;
13422 swig_obj[0] = args;
13423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13424 if (!SWIG_IsOK(res1)) {
13425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13426 }
13427 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (wxOutputStream *)(arg1)->GetOutputStream();
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13435 return resultobj;
13436 fail:
13437 return NULL;
13438 }
13439
13440
13441 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13442 PyObject *resultobj = 0;
13443 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13444 void *argp1 = 0 ;
13445 int res1 = 0 ;
13446 PyObject *swig_obj[1] ;
13447
13448 if (!args) SWIG_fail;
13449 swig_obj[0] = args;
13450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13451 if (!SWIG_IsOK(res1)) {
13452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13453 }
13454 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 (arg1)->CloseOutput();
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 resultobj = SWIG_Py_Void();
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469 PyObject *resultobj = 0;
13470 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13471 bool result;
13472 void *argp1 = 0 ;
13473 int res1 = 0 ;
13474 PyObject *swig_obj[1] ;
13475
13476 if (!args) SWIG_fail;
13477 swig_obj[0] = args;
13478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13481 }
13482 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13501 bool result;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 PyObject *swig_obj[1] ;
13505
13506 if (!args) SWIG_fail;
13507 swig_obj[0] = args;
13508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13511 }
13512 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13521 }
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13529 PyObject *resultobj = 0;
13530 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13531 bool result;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 PyObject *swig_obj[1] ;
13535
13536 if (!args) SWIG_fail;
13537 swig_obj[0] = args;
13538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13539 if (!SWIG_IsOK(res1)) {
13540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13541 }
13542 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13546 wxPyEndAllowThreads(__tstate);
13547 if (PyErr_Occurred()) SWIG_fail;
13548 }
13549 {
13550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13551 }
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13559 PyObject *obj;
13560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13562 return SWIG_Py_Void();
13563 }
13564
13565 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13566 return SWIG_Python_InitShadowInstance(args);
13567 }
13568
13569 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = 0;
13571 int arg1 = (int) 0 ;
13572 int arg2 = (int) 0 ;
13573 int arg3 = (int) 0 ;
13574 wxProcessEvent *result = 0 ;
13575 int val1 ;
13576 int ecode1 = 0 ;
13577 int val2 ;
13578 int ecode2 = 0 ;
13579 int val3 ;
13580 int ecode3 = 0 ;
13581 PyObject * obj0 = 0 ;
13582 PyObject * obj1 = 0 ;
13583 PyObject * obj2 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13589 if (obj0) {
13590 ecode1 = SWIG_AsVal_int(obj0, &val1);
13591 if (!SWIG_IsOK(ecode1)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13593 }
13594 arg1 = static_cast< int >(val1);
13595 }
13596 if (obj1) {
13597 ecode2 = SWIG_AsVal_int(obj1, &val2);
13598 if (!SWIG_IsOK(ecode2)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13600 }
13601 arg2 = static_cast< int >(val2);
13602 }
13603 if (obj2) {
13604 ecode3 = SWIG_AsVal_int(obj2, &val3);
13605 if (!SWIG_IsOK(ecode3)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13607 }
13608 arg3 = static_cast< int >(val3);
13609 }
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13624 PyObject *resultobj = 0;
13625 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13626 int result;
13627 void *argp1 = 0 ;
13628 int res1 = 0 ;
13629 PyObject *swig_obj[1] ;
13630
13631 if (!args) SWIG_fail;
13632 swig_obj[0] = args;
13633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13634 if (!SWIG_IsOK(res1)) {
13635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13636 }
13637 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13638 {
13639 PyThreadState* __tstate = wxPyBeginAllowThreads();
13640 result = (int)(arg1)->GetPid();
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 resultobj = SWIG_From_int(static_cast< int >(result));
13645 return resultobj;
13646 fail:
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13652 PyObject *resultobj = 0;
13653 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13654 int result;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 PyObject *swig_obj[1] ;
13658
13659 if (!args) SWIG_fail;
13660 swig_obj[0] = args;
13661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13662 if (!SWIG_IsOK(res1)) {
13663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13664 }
13665 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 result = (int)(arg1)->GetExitCode();
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 resultobj = SWIG_From_int(static_cast< int >(result));
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13680 PyObject *resultobj = 0;
13681 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13682 int arg2 ;
13683 void *argp1 = 0 ;
13684 int res1 = 0 ;
13685 int val2 ;
13686 int ecode2 = 0 ;
13687 PyObject *swig_obj[2] ;
13688
13689 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13691 if (!SWIG_IsOK(res1)) {
13692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13693 }
13694 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13695 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13696 if (!SWIG_IsOK(ecode2)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13698 }
13699 arg2 = static_cast< int >(val2);
13700 if (arg1) (arg1)->m_pid = arg2;
13701
13702 resultobj = SWIG_Py_Void();
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13710 PyObject *resultobj = 0;
13711 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13712 int result;
13713 void *argp1 = 0 ;
13714 int res1 = 0 ;
13715 PyObject *swig_obj[1] ;
13716
13717 if (!args) SWIG_fail;
13718 swig_obj[0] = args;
13719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13720 if (!SWIG_IsOK(res1)) {
13721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13722 }
13723 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13724 result = (int) ((arg1)->m_pid);
13725 resultobj = SWIG_From_int(static_cast< int >(result));
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13733 PyObject *resultobj = 0;
13734 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13735 int arg2 ;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 int val2 ;
13739 int ecode2 = 0 ;
13740 PyObject *swig_obj[2] ;
13741
13742 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13744 if (!SWIG_IsOK(res1)) {
13745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13746 }
13747 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13748 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13749 if (!SWIG_IsOK(ecode2)) {
13750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13751 }
13752 arg2 = static_cast< int >(val2);
13753 if (arg1) (arg1)->m_exitcode = arg2;
13754
13755 resultobj = SWIG_Py_Void();
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13763 PyObject *resultobj = 0;
13764 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13765 int result;
13766 void *argp1 = 0 ;
13767 int res1 = 0 ;
13768 PyObject *swig_obj[1] ;
13769
13770 if (!args) SWIG_fail;
13771 swig_obj[0] = args;
13772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13773 if (!SWIG_IsOK(res1)) {
13774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13775 }
13776 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13777 result = (int) ((arg1)->m_exitcode);
13778 resultobj = SWIG_From_int(static_cast< int >(result));
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13786 PyObject *obj;
13787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13788 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13789 return SWIG_Py_Void();
13790 }
13791
13792 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13793 return SWIG_Python_InitShadowInstance(args);
13794 }
13795
13796 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13797 PyObject *resultobj = 0;
13798 wxString *arg1 = 0 ;
13799 int arg2 = (int) wxEXEC_ASYNC ;
13800 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13801 long result;
13802 bool temp1 = false ;
13803 int val2 ;
13804 int ecode2 = 0 ;
13805 void *argp3 = 0 ;
13806 int res3 = 0 ;
13807 PyObject * obj0 = 0 ;
13808 PyObject * obj1 = 0 ;
13809 PyObject * obj2 = 0 ;
13810 char * kwnames[] = {
13811 (char *) "command",(char *) "flags",(char *) "process", NULL
13812 };
13813
13814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13815 {
13816 arg1 = wxString_in_helper(obj0);
13817 if (arg1 == NULL) SWIG_fail;
13818 temp1 = true;
13819 }
13820 if (obj1) {
13821 ecode2 = SWIG_AsVal_int(obj1, &val2);
13822 if (!SWIG_IsOK(ecode2)) {
13823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13824 }
13825 arg2 = static_cast< int >(val2);
13826 }
13827 if (obj2) {
13828 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13829 if (!SWIG_IsOK(res3)) {
13830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13831 }
13832 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13833 }
13834 {
13835 if (!wxPyCheckForApp()) SWIG_fail;
13836 PyThreadState* __tstate = wxPyBeginAllowThreads();
13837 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13838 wxPyEndAllowThreads(__tstate);
13839 if (PyErr_Occurred()) SWIG_fail;
13840 }
13841 resultobj = SWIG_From_long(static_cast< long >(result));
13842 {
13843 if (temp1)
13844 delete arg1;
13845 }
13846 return resultobj;
13847 fail:
13848 {
13849 if (temp1)
13850 delete arg1;
13851 }
13852 return NULL;
13853 }
13854
13855
13856 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj = 0;
13858 long arg1 ;
13859 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13860 wxKillError *arg3 = (wxKillError *) 0 ;
13861 int arg4 = (int) wxKILL_NOCHILDREN ;
13862 int result;
13863 long val1 ;
13864 int ecode1 = 0 ;
13865 int val2 ;
13866 int ecode2 = 0 ;
13867 wxKillError temp3 ;
13868 int val4 ;
13869 int ecode4 = 0 ;
13870 PyObject * obj0 = 0 ;
13871 PyObject * obj1 = 0 ;
13872 PyObject * obj2 = 0 ;
13873 char * kwnames[] = {
13874 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13875 };
13876
13877 {
13878 arg3 = &temp3;
13879 }
13880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13881 ecode1 = SWIG_AsVal_long(obj0, &val1);
13882 if (!SWIG_IsOK(ecode1)) {
13883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13884 }
13885 arg1 = static_cast< long >(val1);
13886 if (obj1) {
13887 ecode2 = SWIG_AsVal_int(obj1, &val2);
13888 if (!SWIG_IsOK(ecode2)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13890 }
13891 arg2 = static_cast< wxSignal >(val2);
13892 }
13893 if (obj2) {
13894 ecode4 = SWIG_AsVal_int(obj2, &val4);
13895 if (!SWIG_IsOK(ecode4)) {
13896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13897 }
13898 arg4 = static_cast< int >(val4);
13899 }
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 result = (int)wxKill(arg1,arg2,arg3,arg4);
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 resultobj = SWIG_From_int(static_cast< int >(result));
13907 {
13908 PyObject* o;
13909 o = PyInt_FromLong((long) (*arg3));
13910
13911
13912
13913 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13914
13915 }
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 int arg1 = (int) wxJOYSTICK1 ;
13925 wxJoystick *result = 0 ;
13926 int val1 ;
13927 int ecode1 = 0 ;
13928 PyObject * obj0 = 0 ;
13929 char * kwnames[] = {
13930 (char *) "joystick", NULL
13931 };
13932
13933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13934 if (obj0) {
13935 ecode1 = SWIG_AsVal_int(obj0, &val1);
13936 if (!SWIG_IsOK(ecode1)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13938 }
13939 arg1 = static_cast< int >(val1);
13940 }
13941 {
13942 if (!wxPyCheckForApp()) SWIG_fail;
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 result = (wxJoystick *)new wxJoystick(arg1);
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13949 return resultobj;
13950 fail:
13951 return NULL;
13952 }
13953
13954
13955 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13956 PyObject *resultobj = 0;
13957 wxJoystick *arg1 = (wxJoystick *) 0 ;
13958 void *argp1 = 0 ;
13959 int res1 = 0 ;
13960 PyObject *swig_obj[1] ;
13961
13962 if (!args) SWIG_fail;
13963 swig_obj[0] = args;
13964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13965 if (!SWIG_IsOK(res1)) {
13966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13967 }
13968 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 delete arg1;
13972
13973 wxPyEndAllowThreads(__tstate);
13974 if (PyErr_Occurred()) SWIG_fail;
13975 }
13976 resultobj = SWIG_Py_Void();
13977 return resultobj;
13978 fail:
13979 return NULL;
13980 }
13981
13982
13983 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13984 PyObject *resultobj = 0;
13985 wxJoystick *arg1 = (wxJoystick *) 0 ;
13986 wxPoint result;
13987 void *argp1 = 0 ;
13988 int res1 = 0 ;
13989 PyObject *swig_obj[1] ;
13990
13991 if (!args) SWIG_fail;
13992 swig_obj[0] = args;
13993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13994 if (!SWIG_IsOK(res1)) {
13995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13996 }
13997 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13998 {
13999 PyThreadState* __tstate = wxPyBeginAllowThreads();
14000 result = (arg1)->GetPosition();
14001 wxPyEndAllowThreads(__tstate);
14002 if (PyErr_Occurred()) SWIG_fail;
14003 }
14004 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14005 return resultobj;
14006 fail:
14007 return NULL;
14008 }
14009
14010
14011 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14012 PyObject *resultobj = 0;
14013 wxJoystick *arg1 = (wxJoystick *) 0 ;
14014 int result;
14015 void *argp1 = 0 ;
14016 int res1 = 0 ;
14017 PyObject *swig_obj[1] ;
14018
14019 if (!args) SWIG_fail;
14020 swig_obj[0] = args;
14021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14022 if (!SWIG_IsOK(res1)) {
14023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14024 }
14025 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14026 {
14027 PyThreadState* __tstate = wxPyBeginAllowThreads();
14028 result = (int)(arg1)->GetZPosition();
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 resultobj = SWIG_From_int(static_cast< int >(result));
14033 return resultobj;
14034 fail:
14035 return NULL;
14036 }
14037
14038
14039 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14040 PyObject *resultobj = 0;
14041 wxJoystick *arg1 = (wxJoystick *) 0 ;
14042 int result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 PyObject *swig_obj[1] ;
14046
14047 if (!args) SWIG_fail;
14048 swig_obj[0] = args;
14049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14050 if (!SWIG_IsOK(res1)) {
14051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14052 }
14053 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14054 {
14055 PyThreadState* __tstate = wxPyBeginAllowThreads();
14056 result = (int)(arg1)->GetButtonState();
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 resultobj = SWIG_From_int(static_cast< int >(result));
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14068 PyObject *resultobj = 0;
14069 wxJoystick *arg1 = (wxJoystick *) 0 ;
14070 int result;
14071 void *argp1 = 0 ;
14072 int res1 = 0 ;
14073 PyObject *swig_obj[1] ;
14074
14075 if (!args) SWIG_fail;
14076 swig_obj[0] = args;
14077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14078 if (!SWIG_IsOK(res1)) {
14079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14080 }
14081 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (int)(arg1)->GetPOVPosition();
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 resultobj = SWIG_From_int(static_cast< int >(result));
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14096 PyObject *resultobj = 0;
14097 wxJoystick *arg1 = (wxJoystick *) 0 ;
14098 int result;
14099 void *argp1 = 0 ;
14100 int res1 = 0 ;
14101 PyObject *swig_obj[1] ;
14102
14103 if (!args) SWIG_fail;
14104 swig_obj[0] = args;
14105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14108 }
14109 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (int)(arg1)->GetPOVCTSPosition();
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 resultobj = SWIG_From_int(static_cast< int >(result));
14117 return resultobj;
14118 fail:
14119 return NULL;
14120 }
14121
14122
14123 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14124 PyObject *resultobj = 0;
14125 wxJoystick *arg1 = (wxJoystick *) 0 ;
14126 int result;
14127 void *argp1 = 0 ;
14128 int res1 = 0 ;
14129 PyObject *swig_obj[1] ;
14130
14131 if (!args) SWIG_fail;
14132 swig_obj[0] = args;
14133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14134 if (!SWIG_IsOK(res1)) {
14135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14136 }
14137 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (int)(arg1)->GetRudderPosition();
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 resultobj = SWIG_From_int(static_cast< int >(result));
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14152 PyObject *resultobj = 0;
14153 wxJoystick *arg1 = (wxJoystick *) 0 ;
14154 int result;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 PyObject *swig_obj[1] ;
14158
14159 if (!args) SWIG_fail;
14160 swig_obj[0] = args;
14161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14164 }
14165 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 result = (int)(arg1)->GetUPosition();
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_From_int(static_cast< int >(result));
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14180 PyObject *resultobj = 0;
14181 wxJoystick *arg1 = (wxJoystick *) 0 ;
14182 int result;
14183 void *argp1 = 0 ;
14184 int res1 = 0 ;
14185 PyObject *swig_obj[1] ;
14186
14187 if (!args) SWIG_fail;
14188 swig_obj[0] = args;
14189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14190 if (!SWIG_IsOK(res1)) {
14191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14192 }
14193 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 result = (int)(arg1)->GetVPosition();
14197 wxPyEndAllowThreads(__tstate);
14198 if (PyErr_Occurred()) SWIG_fail;
14199 }
14200 resultobj = SWIG_From_int(static_cast< int >(result));
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14208 PyObject *resultobj = 0;
14209 wxJoystick *arg1 = (wxJoystick *) 0 ;
14210 int result;
14211 void *argp1 = 0 ;
14212 int res1 = 0 ;
14213 PyObject *swig_obj[1] ;
14214
14215 if (!args) SWIG_fail;
14216 swig_obj[0] = args;
14217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14218 if (!SWIG_IsOK(res1)) {
14219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14220 }
14221 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (int)(arg1)->GetMovementThreshold();
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_From_int(static_cast< int >(result));
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 wxJoystick *arg1 = (wxJoystick *) 0 ;
14238 int arg2 ;
14239 void *argp1 = 0 ;
14240 int res1 = 0 ;
14241 int val2 ;
14242 int ecode2 = 0 ;
14243 PyObject * obj0 = 0 ;
14244 PyObject * obj1 = 0 ;
14245 char * kwnames[] = {
14246 (char *) "self",(char *) "threshold", NULL
14247 };
14248
14249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14251 if (!SWIG_IsOK(res1)) {
14252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14253 }
14254 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14255 ecode2 = SWIG_AsVal_int(obj1, &val2);
14256 if (!SWIG_IsOK(ecode2)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14258 }
14259 arg2 = static_cast< int >(val2);
14260 {
14261 PyThreadState* __tstate = wxPyBeginAllowThreads();
14262 (arg1)->SetMovementThreshold(arg2);
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 resultobj = SWIG_Py_Void();
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14274 PyObject *resultobj = 0;
14275 wxJoystick *arg1 = (wxJoystick *) 0 ;
14276 bool result;
14277 void *argp1 = 0 ;
14278 int res1 = 0 ;
14279 PyObject *swig_obj[1] ;
14280
14281 if (!args) SWIG_fail;
14282 swig_obj[0] = args;
14283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14284 if (!SWIG_IsOK(res1)) {
14285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14286 }
14287 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14288 {
14289 PyThreadState* __tstate = wxPyBeginAllowThreads();
14290 result = (bool)(arg1)->IsOk();
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 {
14295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14304 PyObject *resultobj = 0;
14305 wxJoystick *arg1 = (wxJoystick *) 0 ;
14306 int result;
14307 void *argp1 = 0 ;
14308 int res1 = 0 ;
14309 PyObject *swig_obj[1] ;
14310
14311 if (!args) SWIG_fail;
14312 swig_obj[0] = args;
14313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14314 if (!SWIG_IsOK(res1)) {
14315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14316 }
14317 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (int)(arg1)->GetNumberJoysticks();
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = SWIG_From_int(static_cast< int >(result));
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14332 PyObject *resultobj = 0;
14333 wxJoystick *arg1 = (wxJoystick *) 0 ;
14334 int result;
14335 void *argp1 = 0 ;
14336 int res1 = 0 ;
14337 PyObject *swig_obj[1] ;
14338
14339 if (!args) SWIG_fail;
14340 swig_obj[0] = args;
14341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14342 if (!SWIG_IsOK(res1)) {
14343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14344 }
14345 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 result = (int)(arg1)->GetManufacturerId();
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 resultobj = SWIG_From_int(static_cast< int >(result));
14353 return resultobj;
14354 fail:
14355 return NULL;
14356 }
14357
14358
14359 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14360 PyObject *resultobj = 0;
14361 wxJoystick *arg1 = (wxJoystick *) 0 ;
14362 int result;
14363 void *argp1 = 0 ;
14364 int res1 = 0 ;
14365 PyObject *swig_obj[1] ;
14366
14367 if (!args) SWIG_fail;
14368 swig_obj[0] = args;
14369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14372 }
14373 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (int)(arg1)->GetProductId();
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = SWIG_From_int(static_cast< int >(result));
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14388 PyObject *resultobj = 0;
14389 wxJoystick *arg1 = (wxJoystick *) 0 ;
14390 wxString result;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 PyObject *swig_obj[1] ;
14394
14395 if (!args) SWIG_fail;
14396 swig_obj[0] = args;
14397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14398 if (!SWIG_IsOK(res1)) {
14399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14400 }
14401 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 result = (arg1)->GetProductName();
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 {
14409 #if wxUSE_UNICODE
14410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14411 #else
14412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14413 #endif
14414 }
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14422 PyObject *resultobj = 0;
14423 wxJoystick *arg1 = (wxJoystick *) 0 ;
14424 int result;
14425 void *argp1 = 0 ;
14426 int res1 = 0 ;
14427 PyObject *swig_obj[1] ;
14428
14429 if (!args) SWIG_fail;
14430 swig_obj[0] = args;
14431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14432 if (!SWIG_IsOK(res1)) {
14433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14434 }
14435 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (int)(arg1)->GetXMin();
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = SWIG_From_int(static_cast< int >(result));
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14450 PyObject *resultobj = 0;
14451 wxJoystick *arg1 = (wxJoystick *) 0 ;
14452 int result;
14453 void *argp1 = 0 ;
14454 int res1 = 0 ;
14455 PyObject *swig_obj[1] ;
14456
14457 if (!args) SWIG_fail;
14458 swig_obj[0] = args;
14459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14460 if (!SWIG_IsOK(res1)) {
14461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14462 }
14463 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14464 {
14465 PyThreadState* __tstate = wxPyBeginAllowThreads();
14466 result = (int)(arg1)->GetYMin();
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 resultobj = SWIG_From_int(static_cast< int >(result));
14471 return resultobj;
14472 fail:
14473 return NULL;
14474 }
14475
14476
14477 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14478 PyObject *resultobj = 0;
14479 wxJoystick *arg1 = (wxJoystick *) 0 ;
14480 int result;
14481 void *argp1 = 0 ;
14482 int res1 = 0 ;
14483 PyObject *swig_obj[1] ;
14484
14485 if (!args) SWIG_fail;
14486 swig_obj[0] = args;
14487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14488 if (!SWIG_IsOK(res1)) {
14489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14490 }
14491 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (int)(arg1)->GetZMin();
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 resultobj = SWIG_From_int(static_cast< int >(result));
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14506 PyObject *resultobj = 0;
14507 wxJoystick *arg1 = (wxJoystick *) 0 ;
14508 int result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 PyObject *swig_obj[1] ;
14512
14513 if (!args) SWIG_fail;
14514 swig_obj[0] = args;
14515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14516 if (!SWIG_IsOK(res1)) {
14517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14518 }
14519 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 result = (int)(arg1)->GetXMax();
14523 wxPyEndAllowThreads(__tstate);
14524 if (PyErr_Occurred()) SWIG_fail;
14525 }
14526 resultobj = SWIG_From_int(static_cast< int >(result));
14527 return resultobj;
14528 fail:
14529 return NULL;
14530 }
14531
14532
14533 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14534 PyObject *resultobj = 0;
14535 wxJoystick *arg1 = (wxJoystick *) 0 ;
14536 int result;
14537 void *argp1 = 0 ;
14538 int res1 = 0 ;
14539 PyObject *swig_obj[1] ;
14540
14541 if (!args) SWIG_fail;
14542 swig_obj[0] = args;
14543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14544 if (!SWIG_IsOK(res1)) {
14545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14546 }
14547 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14548 {
14549 PyThreadState* __tstate = wxPyBeginAllowThreads();
14550 result = (int)(arg1)->GetYMax();
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 resultobj = SWIG_From_int(static_cast< int >(result));
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14562 PyObject *resultobj = 0;
14563 wxJoystick *arg1 = (wxJoystick *) 0 ;
14564 int result;
14565 void *argp1 = 0 ;
14566 int res1 = 0 ;
14567 PyObject *swig_obj[1] ;
14568
14569 if (!args) SWIG_fail;
14570 swig_obj[0] = args;
14571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14572 if (!SWIG_IsOK(res1)) {
14573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14574 }
14575 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14576 {
14577 PyThreadState* __tstate = wxPyBeginAllowThreads();
14578 result = (int)(arg1)->GetZMax();
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 resultobj = SWIG_From_int(static_cast< int >(result));
14583 return resultobj;
14584 fail:
14585 return NULL;
14586 }
14587
14588
14589 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14590 PyObject *resultobj = 0;
14591 wxJoystick *arg1 = (wxJoystick *) 0 ;
14592 int result;
14593 void *argp1 = 0 ;
14594 int res1 = 0 ;
14595 PyObject *swig_obj[1] ;
14596
14597 if (!args) SWIG_fail;
14598 swig_obj[0] = args;
14599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14600 if (!SWIG_IsOK(res1)) {
14601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14602 }
14603 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 result = (int)(arg1)->GetNumberButtons();
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 resultobj = SWIG_From_int(static_cast< int >(result));
14611 return resultobj;
14612 fail:
14613 return NULL;
14614 }
14615
14616
14617 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14618 PyObject *resultobj = 0;
14619 wxJoystick *arg1 = (wxJoystick *) 0 ;
14620 int result;
14621 void *argp1 = 0 ;
14622 int res1 = 0 ;
14623 PyObject *swig_obj[1] ;
14624
14625 if (!args) SWIG_fail;
14626 swig_obj[0] = args;
14627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14628 if (!SWIG_IsOK(res1)) {
14629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14630 }
14631 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 result = (int)(arg1)->GetNumberAxes();
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 resultobj = SWIG_From_int(static_cast< int >(result));
14639 return resultobj;
14640 fail:
14641 return NULL;
14642 }
14643
14644
14645 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14646 PyObject *resultobj = 0;
14647 wxJoystick *arg1 = (wxJoystick *) 0 ;
14648 int result;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 PyObject *swig_obj[1] ;
14652
14653 if (!args) SWIG_fail;
14654 swig_obj[0] = args;
14655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14656 if (!SWIG_IsOK(res1)) {
14657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14658 }
14659 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14660 {
14661 PyThreadState* __tstate = wxPyBeginAllowThreads();
14662 result = (int)(arg1)->GetMaxButtons();
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 resultobj = SWIG_From_int(static_cast< int >(result));
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14674 PyObject *resultobj = 0;
14675 wxJoystick *arg1 = (wxJoystick *) 0 ;
14676 int result;
14677 void *argp1 = 0 ;
14678 int res1 = 0 ;
14679 PyObject *swig_obj[1] ;
14680
14681 if (!args) SWIG_fail;
14682 swig_obj[0] = args;
14683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14686 }
14687 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (int)(arg1)->GetMaxAxes();
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 resultobj = SWIG_From_int(static_cast< int >(result));
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14702 PyObject *resultobj = 0;
14703 wxJoystick *arg1 = (wxJoystick *) 0 ;
14704 int result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 PyObject *swig_obj[1] ;
14708
14709 if (!args) SWIG_fail;
14710 swig_obj[0] = args;
14711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14714 }
14715 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 result = (int)(arg1)->GetPollingMin();
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 resultobj = SWIG_From_int(static_cast< int >(result));
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxJoystick *arg1 = (wxJoystick *) 0 ;
14732 int result;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14742 }
14743 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (int)(arg1)->GetPollingMax();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_From_int(static_cast< int >(result));
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14758 PyObject *resultobj = 0;
14759 wxJoystick *arg1 = (wxJoystick *) 0 ;
14760 int result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 PyObject *swig_obj[1] ;
14764
14765 if (!args) SWIG_fail;
14766 swig_obj[0] = args;
14767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14770 }
14771 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (int)(arg1)->GetRudderMin();
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 resultobj = SWIG_From_int(static_cast< int >(result));
14779 return resultobj;
14780 fail:
14781 return NULL;
14782 }
14783
14784
14785 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14786 PyObject *resultobj = 0;
14787 wxJoystick *arg1 = (wxJoystick *) 0 ;
14788 int result;
14789 void *argp1 = 0 ;
14790 int res1 = 0 ;
14791 PyObject *swig_obj[1] ;
14792
14793 if (!args) SWIG_fail;
14794 swig_obj[0] = args;
14795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14796 if (!SWIG_IsOK(res1)) {
14797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14798 }
14799 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (int)(arg1)->GetRudderMax();
14803 wxPyEndAllowThreads(__tstate);
14804 if (PyErr_Occurred()) SWIG_fail;
14805 }
14806 resultobj = SWIG_From_int(static_cast< int >(result));
14807 return resultobj;
14808 fail:
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14814 PyObject *resultobj = 0;
14815 wxJoystick *arg1 = (wxJoystick *) 0 ;
14816 int result;
14817 void *argp1 = 0 ;
14818 int res1 = 0 ;
14819 PyObject *swig_obj[1] ;
14820
14821 if (!args) SWIG_fail;
14822 swig_obj[0] = args;
14823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14824 if (!SWIG_IsOK(res1)) {
14825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14826 }
14827 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14828 {
14829 PyThreadState* __tstate = wxPyBeginAllowThreads();
14830 result = (int)(arg1)->GetUMin();
14831 wxPyEndAllowThreads(__tstate);
14832 if (PyErr_Occurred()) SWIG_fail;
14833 }
14834 resultobj = SWIG_From_int(static_cast< int >(result));
14835 return resultobj;
14836 fail:
14837 return NULL;
14838 }
14839
14840
14841 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14842 PyObject *resultobj = 0;
14843 wxJoystick *arg1 = (wxJoystick *) 0 ;
14844 int result;
14845 void *argp1 = 0 ;
14846 int res1 = 0 ;
14847 PyObject *swig_obj[1] ;
14848
14849 if (!args) SWIG_fail;
14850 swig_obj[0] = args;
14851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14852 if (!SWIG_IsOK(res1)) {
14853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14854 }
14855 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (int)(arg1)->GetUMax();
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 resultobj = SWIG_From_int(static_cast< int >(result));
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14870 PyObject *resultobj = 0;
14871 wxJoystick *arg1 = (wxJoystick *) 0 ;
14872 int result;
14873 void *argp1 = 0 ;
14874 int res1 = 0 ;
14875 PyObject *swig_obj[1] ;
14876
14877 if (!args) SWIG_fail;
14878 swig_obj[0] = args;
14879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14880 if (!SWIG_IsOK(res1)) {
14881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14882 }
14883 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14884 {
14885 PyThreadState* __tstate = wxPyBeginAllowThreads();
14886 result = (int)(arg1)->GetVMin();
14887 wxPyEndAllowThreads(__tstate);
14888 if (PyErr_Occurred()) SWIG_fail;
14889 }
14890 resultobj = SWIG_From_int(static_cast< int >(result));
14891 return resultobj;
14892 fail:
14893 return NULL;
14894 }
14895
14896
14897 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14898 PyObject *resultobj = 0;
14899 wxJoystick *arg1 = (wxJoystick *) 0 ;
14900 int result;
14901 void *argp1 = 0 ;
14902 int res1 = 0 ;
14903 PyObject *swig_obj[1] ;
14904
14905 if (!args) SWIG_fail;
14906 swig_obj[0] = args;
14907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14908 if (!SWIG_IsOK(res1)) {
14909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14910 }
14911 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (int)(arg1)->GetVMax();
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 resultobj = SWIG_From_int(static_cast< int >(result));
14919 return resultobj;
14920 fail:
14921 return NULL;
14922 }
14923
14924
14925 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14926 PyObject *resultobj = 0;
14927 wxJoystick *arg1 = (wxJoystick *) 0 ;
14928 bool result;
14929 void *argp1 = 0 ;
14930 int res1 = 0 ;
14931 PyObject *swig_obj[1] ;
14932
14933 if (!args) SWIG_fail;
14934 swig_obj[0] = args;
14935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14936 if (!SWIG_IsOK(res1)) {
14937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14938 }
14939 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (bool)(arg1)->HasRudder();
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 {
14947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14948 }
14949 return resultobj;
14950 fail:
14951 return NULL;
14952 }
14953
14954
14955 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14956 PyObject *resultobj = 0;
14957 wxJoystick *arg1 = (wxJoystick *) 0 ;
14958 bool result;
14959 void *argp1 = 0 ;
14960 int res1 = 0 ;
14961 PyObject *swig_obj[1] ;
14962
14963 if (!args) SWIG_fail;
14964 swig_obj[0] = args;
14965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14968 }
14969 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (bool)(arg1)->HasZ();
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 {
14977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14978 }
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14986 PyObject *resultobj = 0;
14987 wxJoystick *arg1 = (wxJoystick *) 0 ;
14988 bool result;
14989 void *argp1 = 0 ;
14990 int res1 = 0 ;
14991 PyObject *swig_obj[1] ;
14992
14993 if (!args) SWIG_fail;
14994 swig_obj[0] = args;
14995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14998 }
14999 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (bool)(arg1)->HasU();
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 {
15007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15008 }
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15016 PyObject *resultobj = 0;
15017 wxJoystick *arg1 = (wxJoystick *) 0 ;
15018 bool result;
15019 void *argp1 = 0 ;
15020 int res1 = 0 ;
15021 PyObject *swig_obj[1] ;
15022
15023 if (!args) SWIG_fail;
15024 swig_obj[0] = args;
15025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15028 }
15029 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (bool)(arg1)->HasV();
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 {
15037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15038 }
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *resultobj = 0;
15047 wxJoystick *arg1 = (wxJoystick *) 0 ;
15048 bool result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 PyObject *swig_obj[1] ;
15052
15053 if (!args) SWIG_fail;
15054 swig_obj[0] = args;
15055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15058 }
15059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (bool)(arg1)->HasPOV();
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 {
15067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15068 }
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxJoystick *arg1 = (wxJoystick *) 0 ;
15078 bool result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15088 }
15089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (bool)(arg1)->HasPOV4Dir();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 {
15097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15098 }
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 PyObject *resultobj = 0;
15107 wxJoystick *arg1 = (wxJoystick *) 0 ;
15108 bool result;
15109 void *argp1 = 0 ;
15110 int res1 = 0 ;
15111 PyObject *swig_obj[1] ;
15112
15113 if (!args) SWIG_fail;
15114 swig_obj[0] = args;
15115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15116 if (!SWIG_IsOK(res1)) {
15117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15118 }
15119 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (bool)(arg1)->HasPOVCTS();
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 {
15127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15128 }
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxJoystick *arg1 = (wxJoystick *) 0 ;
15138 wxWindow *arg2 = (wxWindow *) 0 ;
15139 int arg3 = (int) 0 ;
15140 bool result;
15141 void *argp1 = 0 ;
15142 int res1 = 0 ;
15143 void *argp2 = 0 ;
15144 int res2 = 0 ;
15145 int val3 ;
15146 int ecode3 = 0 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 PyObject * obj2 = 0 ;
15150 char * kwnames[] = {
15151 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15152 };
15153
15154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15158 }
15159 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15161 if (!SWIG_IsOK(res2)) {
15162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15163 }
15164 arg2 = reinterpret_cast< wxWindow * >(argp2);
15165 if (obj2) {
15166 ecode3 = SWIG_AsVal_int(obj2, &val3);
15167 if (!SWIG_IsOK(ecode3)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15169 }
15170 arg3 = static_cast< int >(val3);
15171 }
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 result = (bool)(arg1)->SetCapture(arg2,arg3);
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 {
15179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15180 }
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *resultobj = 0;
15189 wxJoystick *arg1 = (wxJoystick *) 0 ;
15190 bool result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 PyObject *swig_obj[1] ;
15194
15195 if (!args) SWIG_fail;
15196 swig_obj[0] = args;
15197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15200 }
15201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (bool)(arg1)->ReleaseCapture();
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 {
15209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15210 }
15211 return resultobj;
15212 fail:
15213 return NULL;
15214 }
15215
15216
15217 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15218 PyObject *obj;
15219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15220 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15221 return SWIG_Py_Void();
15222 }
15223
15224 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15225 return SWIG_Python_InitShadowInstance(args);
15226 }
15227
15228 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15231 int arg2 = (int) 0 ;
15232 int arg3 = (int) wxJOYSTICK1 ;
15233 int arg4 = (int) 0 ;
15234 wxJoystickEvent *result = 0 ;
15235 int val1 ;
15236 int ecode1 = 0 ;
15237 int val2 ;
15238 int ecode2 = 0 ;
15239 int val3 ;
15240 int ecode3 = 0 ;
15241 int val4 ;
15242 int ecode4 = 0 ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 PyObject * obj2 = 0 ;
15246 PyObject * obj3 = 0 ;
15247 char * kwnames[] = {
15248 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15249 };
15250
15251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15252 if (obj0) {
15253 ecode1 = SWIG_AsVal_int(obj0, &val1);
15254 if (!SWIG_IsOK(ecode1)) {
15255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15256 }
15257 arg1 = static_cast< wxEventType >(val1);
15258 }
15259 if (obj1) {
15260 ecode2 = SWIG_AsVal_int(obj1, &val2);
15261 if (!SWIG_IsOK(ecode2)) {
15262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15263 }
15264 arg2 = static_cast< int >(val2);
15265 }
15266 if (obj2) {
15267 ecode3 = SWIG_AsVal_int(obj2, &val3);
15268 if (!SWIG_IsOK(ecode3)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15270 }
15271 arg3 = static_cast< int >(val3);
15272 }
15273 if (obj3) {
15274 ecode4 = SWIG_AsVal_int(obj3, &val4);
15275 if (!SWIG_IsOK(ecode4)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15277 }
15278 arg4 = static_cast< int >(val4);
15279 }
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15294 PyObject *resultobj = 0;
15295 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15296 wxPoint result;
15297 void *argp1 = 0 ;
15298 int res1 = 0 ;
15299 PyObject *swig_obj[1] ;
15300
15301 if (!args) SWIG_fail;
15302 swig_obj[0] = args;
15303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15304 if (!SWIG_IsOK(res1)) {
15305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15306 }
15307 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15308 {
15309 PyThreadState* __tstate = wxPyBeginAllowThreads();
15310 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 PyObject *resultobj = 0;
15323 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15324 int result;
15325 void *argp1 = 0 ;
15326 int res1 = 0 ;
15327 PyObject *swig_obj[1] ;
15328
15329 if (!args) SWIG_fail;
15330 swig_obj[0] = args;
15331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15332 if (!SWIG_IsOK(res1)) {
15333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15334 }
15335 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 resultobj = SWIG_From_int(static_cast< int >(result));
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15350 PyObject *resultobj = 0;
15351 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15352 int result;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 PyObject *swig_obj[1] ;
15356
15357 if (!args) SWIG_fail;
15358 swig_obj[0] = args;
15359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15360 if (!SWIG_IsOK(res1)) {
15361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15362 }
15363 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 resultobj = SWIG_From_int(static_cast< int >(result));
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15378 PyObject *resultobj = 0;
15379 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15380 int result;
15381 void *argp1 = 0 ;
15382 int res1 = 0 ;
15383 PyObject *swig_obj[1] ;
15384
15385 if (!args) SWIG_fail;
15386 swig_obj[0] = args;
15387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15388 if (!SWIG_IsOK(res1)) {
15389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15390 }
15391 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 resultobj = SWIG_From_int(static_cast< int >(result));
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15406 PyObject *resultobj = 0;
15407 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15408 int result;
15409 void *argp1 = 0 ;
15410 int res1 = 0 ;
15411 PyObject *swig_obj[1] ;
15412
15413 if (!args) SWIG_fail;
15414 swig_obj[0] = args;
15415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15416 if (!SWIG_IsOK(res1)) {
15417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15418 }
15419 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15423 wxPyEndAllowThreads(__tstate);
15424 if (PyErr_Occurred()) SWIG_fail;
15425 }
15426 resultobj = SWIG_From_int(static_cast< int >(result));
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj = 0;
15435 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15436 int arg2 ;
15437 void *argp1 = 0 ;
15438 int res1 = 0 ;
15439 int val2 ;
15440 int ecode2 = 0 ;
15441 PyObject * obj0 = 0 ;
15442 PyObject * obj1 = 0 ;
15443 char * kwnames[] = {
15444 (char *) "self",(char *) "stick", NULL
15445 };
15446
15447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15449 if (!SWIG_IsOK(res1)) {
15450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15451 }
15452 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15453 ecode2 = SWIG_AsVal_int(obj1, &val2);
15454 if (!SWIG_IsOK(ecode2)) {
15455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15456 }
15457 arg2 = static_cast< int >(val2);
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 (arg1)->SetJoystick(arg2);
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 resultobj = SWIG_Py_Void();
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj = 0;
15473 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15474 int arg2 ;
15475 void *argp1 = 0 ;
15476 int res1 = 0 ;
15477 int val2 ;
15478 int ecode2 = 0 ;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char * kwnames[] = {
15482 (char *) "self",(char *) "state", NULL
15483 };
15484
15485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15489 }
15490 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15491 ecode2 = SWIG_AsVal_int(obj1, &val2);
15492 if (!SWIG_IsOK(ecode2)) {
15493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15494 }
15495 arg2 = static_cast< int >(val2);
15496 {
15497 PyThreadState* __tstate = wxPyBeginAllowThreads();
15498 (arg1)->SetButtonState(arg2);
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 resultobj = SWIG_Py_Void();
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj = 0;
15511 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15512 int arg2 ;
15513 void *argp1 = 0 ;
15514 int res1 = 0 ;
15515 int val2 ;
15516 int ecode2 = 0 ;
15517 PyObject * obj0 = 0 ;
15518 PyObject * obj1 = 0 ;
15519 char * kwnames[] = {
15520 (char *) "self",(char *) "change", NULL
15521 };
15522
15523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15525 if (!SWIG_IsOK(res1)) {
15526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15527 }
15528 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15529 ecode2 = SWIG_AsVal_int(obj1, &val2);
15530 if (!SWIG_IsOK(ecode2)) {
15531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15532 }
15533 arg2 = static_cast< int >(val2);
15534 {
15535 PyThreadState* __tstate = wxPyBeginAllowThreads();
15536 (arg1)->SetButtonChange(arg2);
15537 wxPyEndAllowThreads(__tstate);
15538 if (PyErr_Occurred()) SWIG_fail;
15539 }
15540 resultobj = SWIG_Py_Void();
15541 return resultobj;
15542 fail:
15543 return NULL;
15544 }
15545
15546
15547 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15548 PyObject *resultobj = 0;
15549 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15550 wxPoint *arg2 = 0 ;
15551 void *argp1 = 0 ;
15552 int res1 = 0 ;
15553 wxPoint temp2 ;
15554 PyObject * obj0 = 0 ;
15555 PyObject * obj1 = 0 ;
15556 char * kwnames[] = {
15557 (char *) "self",(char *) "pos", NULL
15558 };
15559
15560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15562 if (!SWIG_IsOK(res1)) {
15563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15564 }
15565 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15566 {
15567 arg2 = &temp2;
15568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15569 }
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 (arg1)->SetPosition((wxPoint const &)*arg2);
15573 wxPyEndAllowThreads(__tstate);
15574 if (PyErr_Occurred()) SWIG_fail;
15575 }
15576 resultobj = SWIG_Py_Void();
15577 return resultobj;
15578 fail:
15579 return NULL;
15580 }
15581
15582
15583 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15584 PyObject *resultobj = 0;
15585 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15586 int arg2 ;
15587 void *argp1 = 0 ;
15588 int res1 = 0 ;
15589 int val2 ;
15590 int ecode2 = 0 ;
15591 PyObject * obj0 = 0 ;
15592 PyObject * obj1 = 0 ;
15593 char * kwnames[] = {
15594 (char *) "self",(char *) "zPos", NULL
15595 };
15596
15597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15601 }
15602 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15603 ecode2 = SWIG_AsVal_int(obj1, &val2);
15604 if (!SWIG_IsOK(ecode2)) {
15605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15606 }
15607 arg2 = static_cast< int >(val2);
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 (arg1)->SetZPosition(arg2);
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_Py_Void();
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15622 PyObject *resultobj = 0;
15623 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15624 bool result;
15625 void *argp1 = 0 ;
15626 int res1 = 0 ;
15627 PyObject *swig_obj[1] ;
15628
15629 if (!args) SWIG_fail;
15630 swig_obj[0] = args;
15631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15634 }
15635 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15636 {
15637 PyThreadState* __tstate = wxPyBeginAllowThreads();
15638 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 {
15643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15644 }
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15654 bool result;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15664 }
15665 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15674 }
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15684 bool result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15694 }
15695 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 {
15703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj = 0;
15713 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15714 int arg2 = (int) wxJOY_BUTTON_ANY ;
15715 bool result;
15716 void *argp1 = 0 ;
15717 int res1 = 0 ;
15718 int val2 ;
15719 int ecode2 = 0 ;
15720 PyObject * obj0 = 0 ;
15721 PyObject * obj1 = 0 ;
15722 char * kwnames[] = {
15723 (char *) "self",(char *) "but", NULL
15724 };
15725
15726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15730 }
15731 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15732 if (obj1) {
15733 ecode2 = SWIG_AsVal_int(obj1, &val2);
15734 if (!SWIG_IsOK(ecode2)) {
15735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15736 }
15737 arg2 = static_cast< int >(val2);
15738 }
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 {
15746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15747 }
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15755 PyObject *resultobj = 0;
15756 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15757 int arg2 = (int) wxJOY_BUTTON_ANY ;
15758 bool result;
15759 void *argp1 = 0 ;
15760 int res1 = 0 ;
15761 int val2 ;
15762 int ecode2 = 0 ;
15763 PyObject * obj0 = 0 ;
15764 PyObject * obj1 = 0 ;
15765 char * kwnames[] = {
15766 (char *) "self",(char *) "but", NULL
15767 };
15768
15769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15771 if (!SWIG_IsOK(res1)) {
15772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15773 }
15774 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15775 if (obj1) {
15776 ecode2 = SWIG_AsVal_int(obj1, &val2);
15777 if (!SWIG_IsOK(ecode2)) {
15778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15779 }
15780 arg2 = static_cast< int >(val2);
15781 }
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15785 wxPyEndAllowThreads(__tstate);
15786 if (PyErr_Occurred()) SWIG_fail;
15787 }
15788 {
15789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15790 }
15791 return resultobj;
15792 fail:
15793 return NULL;
15794 }
15795
15796
15797 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15798 PyObject *resultobj = 0;
15799 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15800 int arg2 = (int) wxJOY_BUTTON_ANY ;
15801 bool result;
15802 void *argp1 = 0 ;
15803 int res1 = 0 ;
15804 int val2 ;
15805 int ecode2 = 0 ;
15806 PyObject * obj0 = 0 ;
15807 PyObject * obj1 = 0 ;
15808 char * kwnames[] = {
15809 (char *) "self",(char *) "but", NULL
15810 };
15811
15812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15814 if (!SWIG_IsOK(res1)) {
15815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15816 }
15817 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15818 if (obj1) {
15819 ecode2 = SWIG_AsVal_int(obj1, &val2);
15820 if (!SWIG_IsOK(ecode2)) {
15821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15822 }
15823 arg2 = static_cast< int >(val2);
15824 }
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15828 wxPyEndAllowThreads(__tstate);
15829 if (PyErr_Occurred()) SWIG_fail;
15830 }
15831 {
15832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15833 }
15834 return resultobj;
15835 fail:
15836 return NULL;
15837 }
15838
15839
15840 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15841 PyObject *obj;
15842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15843 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15844 return SWIG_Py_Void();
15845 }
15846
15847 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15848 return SWIG_Python_InitShadowInstance(args);
15849 }
15850
15851 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj = 0;
15853 wxString const &arg1_defvalue = wxPyEmptyString ;
15854 wxString *arg1 = (wxString *) &arg1_defvalue ;
15855 wxSound *result = 0 ;
15856 bool temp1 = false ;
15857 PyObject * obj0 = 0 ;
15858 char * kwnames[] = {
15859 (char *) "fileName", NULL
15860 };
15861
15862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15863 if (obj0) {
15864 {
15865 arg1 = wxString_in_helper(obj0);
15866 if (arg1 == NULL) SWIG_fail;
15867 temp1 = true;
15868 }
15869 }
15870 {
15871 if (!wxPyCheckForApp()) SWIG_fail;
15872 PyThreadState* __tstate = wxPyBeginAllowThreads();
15873 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15874 wxPyEndAllowThreads(__tstate);
15875 if (PyErr_Occurred()) SWIG_fail;
15876 }
15877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15878 {
15879 if (temp1)
15880 delete arg1;
15881 }
15882 return resultobj;
15883 fail:
15884 {
15885 if (temp1)
15886 delete arg1;
15887 }
15888 return NULL;
15889 }
15890
15891
15892 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15893 PyObject *resultobj = 0;
15894 PyObject *arg1 = (PyObject *) 0 ;
15895 wxSound *result = 0 ;
15896 PyObject * obj0 = 0 ;
15897 char * kwnames[] = {
15898 (char *) "data", NULL
15899 };
15900
15901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15902 arg1 = obj0;
15903 {
15904 if (!wxPyCheckForApp()) SWIG_fail;
15905 PyThreadState* __tstate = wxPyBeginAllowThreads();
15906 result = (wxSound *)new_wxSound(arg1);
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15918 PyObject *resultobj = 0;
15919 wxSound *arg1 = (wxSound *) 0 ;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 PyObject *swig_obj[1] ;
15923
15924 if (!args) SWIG_fail;
15925 swig_obj[0] = args;
15926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15927 if (!SWIG_IsOK(res1)) {
15928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15929 }
15930 arg1 = reinterpret_cast< wxSound * >(argp1);
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 delete arg1;
15934
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 resultobj = SWIG_Py_Void();
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj = 0;
15947 wxSound *arg1 = (wxSound *) 0 ;
15948 wxString *arg2 = 0 ;
15949 bool result;
15950 void *argp1 = 0 ;
15951 int res1 = 0 ;
15952 bool temp2 = false ;
15953 PyObject * obj0 = 0 ;
15954 PyObject * obj1 = 0 ;
15955 char * kwnames[] = {
15956 (char *) "self",(char *) "fileName", NULL
15957 };
15958
15959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15961 if (!SWIG_IsOK(res1)) {
15962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15963 }
15964 arg1 = reinterpret_cast< wxSound * >(argp1);
15965 {
15966 arg2 = wxString_in_helper(obj1);
15967 if (arg2 == NULL) SWIG_fail;
15968 temp2 = true;
15969 }
15970 {
15971 PyThreadState* __tstate = wxPyBeginAllowThreads();
15972 result = (bool)(arg1)->Create((wxString const &)*arg2);
15973 wxPyEndAllowThreads(__tstate);
15974 if (PyErr_Occurred()) SWIG_fail;
15975 }
15976 {
15977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15978 }
15979 {
15980 if (temp2)
15981 delete arg2;
15982 }
15983 return resultobj;
15984 fail:
15985 {
15986 if (temp2)
15987 delete arg2;
15988 }
15989 return NULL;
15990 }
15991
15992
15993 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15994 PyObject *resultobj = 0;
15995 wxSound *arg1 = (wxSound *) 0 ;
15996 PyObject *arg2 = (PyObject *) 0 ;
15997 bool result;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 PyObject * obj0 = 0 ;
16001 PyObject * obj1 = 0 ;
16002 char * kwnames[] = {
16003 (char *) "self",(char *) "data", NULL
16004 };
16005
16006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16010 }
16011 arg1 = reinterpret_cast< wxSound * >(argp1);
16012 arg2 = obj1;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)wxSound_CreateFromData(arg1,arg2);
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 {
16020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16021 }
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16029 PyObject *resultobj = 0;
16030 wxSound *arg1 = (wxSound *) 0 ;
16031 bool result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 PyObject *swig_obj[1] ;
16035
16036 if (!args) SWIG_fail;
16037 swig_obj[0] = args;
16038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16039 if (!SWIG_IsOK(res1)) {
16040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16041 }
16042 arg1 = reinterpret_cast< wxSound * >(argp1);
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)(arg1)->IsOk();
16046 wxPyEndAllowThreads(__tstate);
16047 if (PyErr_Occurred()) SWIG_fail;
16048 }
16049 {
16050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16051 }
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj = 0;
16060 wxSound *arg1 = (wxSound *) 0 ;
16061 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16062 bool result;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 unsigned int val2 ;
16066 int ecode2 = 0 ;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 char * kwnames[] = {
16070 (char *) "self",(char *) "flags", NULL
16071 };
16072
16073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16075 if (!SWIG_IsOK(res1)) {
16076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16077 }
16078 arg1 = reinterpret_cast< wxSound * >(argp1);
16079 if (obj1) {
16080 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16081 if (!SWIG_IsOK(ecode2)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16083 }
16084 arg2 = static_cast< unsigned int >(val2);
16085 }
16086 {
16087 if (!wxPyCheckForApp()) SWIG_fail;
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 result = (bool)((wxSound const *)arg1)->Play(arg2);
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 {
16094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16095 }
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj = 0;
16104 wxString *arg1 = 0 ;
16105 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16106 bool result;
16107 bool temp1 = false ;
16108 unsigned int val2 ;
16109 int ecode2 = 0 ;
16110 PyObject * obj0 = 0 ;
16111 PyObject * obj1 = 0 ;
16112 char * kwnames[] = {
16113 (char *) "filename",(char *) "flags", NULL
16114 };
16115
16116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16117 {
16118 arg1 = wxString_in_helper(obj0);
16119 if (arg1 == NULL) SWIG_fail;
16120 temp1 = true;
16121 }
16122 if (obj1) {
16123 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16124 if (!SWIG_IsOK(ecode2)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16126 }
16127 arg2 = static_cast< unsigned int >(val2);
16128 }
16129 {
16130 if (!wxPyCheckForApp()) SWIG_fail;
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 {
16137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16138 }
16139 {
16140 if (temp1)
16141 delete arg1;
16142 }
16143 return resultobj;
16144 fail:
16145 {
16146 if (temp1)
16147 delete arg1;
16148 }
16149 return NULL;
16150 }
16151
16152
16153 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16154 PyObject *resultobj = 0;
16155
16156 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16157 {
16158 if (!wxPyCheckForApp()) SWIG_fail;
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 wxSound::Stop();
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 resultobj = SWIG_Py_Void();
16165 return resultobj;
16166 fail:
16167 return NULL;
16168 }
16169
16170
16171 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16172 PyObject *obj;
16173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16174 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16175 return SWIG_Py_Void();
16176 }
16177
16178 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16179 return SWIG_Python_InitShadowInstance(args);
16180 }
16181
16182 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16183 PyObject *resultobj = 0;
16184 wxString *arg1 = 0 ;
16185 wxString *arg2 = 0 ;
16186 wxString *arg3 = 0 ;
16187 wxString *arg4 = 0 ;
16188 wxFileTypeInfo *result = 0 ;
16189 bool temp1 = false ;
16190 bool temp2 = false ;
16191 bool temp3 = false ;
16192 bool temp4 = false ;
16193 PyObject * obj0 = 0 ;
16194 PyObject * obj1 = 0 ;
16195 PyObject * obj2 = 0 ;
16196 PyObject * obj3 = 0 ;
16197 char * kwnames[] = {
16198 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16199 };
16200
16201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16202 {
16203 arg1 = wxString_in_helper(obj0);
16204 if (arg1 == NULL) SWIG_fail;
16205 temp1 = true;
16206 }
16207 {
16208 arg2 = wxString_in_helper(obj1);
16209 if (arg2 == NULL) SWIG_fail;
16210 temp2 = true;
16211 }
16212 {
16213 arg3 = wxString_in_helper(obj2);
16214 if (arg3 == NULL) SWIG_fail;
16215 temp3 = true;
16216 }
16217 {
16218 arg4 = wxString_in_helper(obj3);
16219 if (arg4 == NULL) SWIG_fail;
16220 temp4 = true;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16229 {
16230 if (temp1)
16231 delete arg1;
16232 }
16233 {
16234 if (temp2)
16235 delete arg2;
16236 }
16237 {
16238 if (temp3)
16239 delete arg3;
16240 }
16241 {
16242 if (temp4)
16243 delete arg4;
16244 }
16245 return resultobj;
16246 fail:
16247 {
16248 if (temp1)
16249 delete arg1;
16250 }
16251 {
16252 if (temp2)
16253 delete arg2;
16254 }
16255 {
16256 if (temp3)
16257 delete arg3;
16258 }
16259 {
16260 if (temp4)
16261 delete arg4;
16262 }
16263 return NULL;
16264 }
16265
16266
16267 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16268 PyObject *resultobj = 0;
16269 wxArrayString *arg1 = 0 ;
16270 wxFileTypeInfo *result = 0 ;
16271 bool temp1 = false ;
16272 PyObject * obj0 = 0 ;
16273 char * kwnames[] = {
16274 (char *) "sArray", NULL
16275 };
16276
16277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16278 {
16279 if (! PySequence_Check(obj0)) {
16280 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16281 SWIG_fail;
16282 }
16283 arg1 = new wxArrayString;
16284 temp1 = true;
16285 int i, len=PySequence_Length(obj0);
16286 for (i=0; i<len; i++) {
16287 PyObject* item = PySequence_GetItem(obj0, i);
16288 wxString* s = wxString_in_helper(item);
16289 if (PyErr_Occurred()) SWIG_fail;
16290 arg1->Add(*s);
16291 delete s;
16292 Py_DECREF(item);
16293 }
16294 }
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16298 wxPyEndAllowThreads(__tstate);
16299 if (PyErr_Occurred()) SWIG_fail;
16300 }
16301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16302 {
16303 if (temp1) delete arg1;
16304 }
16305 return resultobj;
16306 fail:
16307 {
16308 if (temp1) delete arg1;
16309 }
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 wxFileTypeInfo *result = 0 ;
16317
16318 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16319 {
16320 PyThreadState* __tstate = wxPyBeginAllowThreads();
16321 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16333 PyObject *resultobj = 0;
16334 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16335 bool result;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 PyObject *swig_obj[1] ;
16339
16340 if (!args) SWIG_fail;
16341 swig_obj[0] = args;
16342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16343 if (!SWIG_IsOK(res1)) {
16344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16345 }
16346 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16347 {
16348 PyThreadState* __tstate = wxPyBeginAllowThreads();
16349 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16350 wxPyEndAllowThreads(__tstate);
16351 if (PyErr_Occurred()) SWIG_fail;
16352 }
16353 {
16354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16355 }
16356 return resultobj;
16357 fail:
16358 return NULL;
16359 }
16360
16361
16362 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16363 PyObject *resultobj = 0;
16364 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16365 wxString *arg2 = 0 ;
16366 int arg3 = (int) 0 ;
16367 void *argp1 = 0 ;
16368 int res1 = 0 ;
16369 bool temp2 = false ;
16370 int val3 ;
16371 int ecode3 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 char * kwnames[] = {
16376 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16377 };
16378
16379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16381 if (!SWIG_IsOK(res1)) {
16382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16383 }
16384 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16385 {
16386 arg2 = wxString_in_helper(obj1);
16387 if (arg2 == NULL) SWIG_fail;
16388 temp2 = true;
16389 }
16390 if (obj2) {
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 }
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 resultobj = SWIG_Py_Void();
16404 {
16405 if (temp2)
16406 delete arg2;
16407 }
16408 return resultobj;
16409 fail:
16410 {
16411 if (temp2)
16412 delete arg2;
16413 }
16414 return NULL;
16415 }
16416
16417
16418 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16419 PyObject *resultobj = 0;
16420 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16421 wxString *arg2 = 0 ;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 bool temp2 = false ;
16425 PyObject * obj0 = 0 ;
16426 PyObject * obj1 = 0 ;
16427 char * kwnames[] = {
16428 (char *) "self",(char *) "shortDesc", NULL
16429 };
16430
16431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16433 if (!SWIG_IsOK(res1)) {
16434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16435 }
16436 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16437 {
16438 arg2 = wxString_in_helper(obj1);
16439 if (arg2 == NULL) SWIG_fail;
16440 temp2 = true;
16441 }
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 (arg1)->SetShortDesc((wxString const &)*arg2);
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 resultobj = SWIG_Py_Void();
16449 {
16450 if (temp2)
16451 delete arg2;
16452 }
16453 return resultobj;
16454 fail:
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 return NULL;
16460 }
16461
16462
16463 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16464 PyObject *resultobj = 0;
16465 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16466 wxString *result = 0 ;
16467 void *argp1 = 0 ;
16468 int res1 = 0 ;
16469 PyObject *swig_obj[1] ;
16470
16471 if (!args) SWIG_fail;
16472 swig_obj[0] = args;
16473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16474 if (!SWIG_IsOK(res1)) {
16475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16476 }
16477 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16478 {
16479 PyThreadState* __tstate = wxPyBeginAllowThreads();
16480 {
16481 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16482 result = (wxString *) &_result_ref;
16483 }
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 {
16488 #if wxUSE_UNICODE
16489 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16490 #else
16491 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16492 #endif
16493 }
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16501 PyObject *resultobj = 0;
16502 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16503 wxString *result = 0 ;
16504 void *argp1 = 0 ;
16505 int res1 = 0 ;
16506 PyObject *swig_obj[1] ;
16507
16508 if (!args) SWIG_fail;
16509 swig_obj[0] = args;
16510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16511 if (!SWIG_IsOK(res1)) {
16512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16513 }
16514 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 {
16518 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16519 result = (wxString *) &_result_ref;
16520 }
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 #if wxUSE_UNICODE
16526 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16527 #else
16528 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16529 #endif
16530 }
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16538 PyObject *resultobj = 0;
16539 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16540 wxString *result = 0 ;
16541 void *argp1 = 0 ;
16542 int res1 = 0 ;
16543 PyObject *swig_obj[1] ;
16544
16545 if (!args) SWIG_fail;
16546 swig_obj[0] = args;
16547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16548 if (!SWIG_IsOK(res1)) {
16549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16550 }
16551 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 {
16555 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16556 result = (wxString *) &_result_ref;
16557 }
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 {
16562 #if wxUSE_UNICODE
16563 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16564 #else
16565 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16566 #endif
16567 }
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16575 PyObject *resultobj = 0;
16576 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16577 wxString *result = 0 ;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 PyObject *swig_obj[1] ;
16581
16582 if (!args) SWIG_fail;
16583 swig_obj[0] = args;
16584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16585 if (!SWIG_IsOK(res1)) {
16586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16587 }
16588 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 {
16592 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16593 result = (wxString *) &_result_ref;
16594 }
16595 wxPyEndAllowThreads(__tstate);
16596 if (PyErr_Occurred()) SWIG_fail;
16597 }
16598 {
16599 #if wxUSE_UNICODE
16600 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16601 #else
16602 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16603 #endif
16604 }
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16612 PyObject *resultobj = 0;
16613 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16614 wxString *result = 0 ;
16615 void *argp1 = 0 ;
16616 int res1 = 0 ;
16617 PyObject *swig_obj[1] ;
16618
16619 if (!args) SWIG_fail;
16620 swig_obj[0] = args;
16621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16622 if (!SWIG_IsOK(res1)) {
16623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16624 }
16625 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 {
16629 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16630 result = (wxString *) &_result_ref;
16631 }
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 {
16636 #if wxUSE_UNICODE
16637 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16638 #else
16639 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16640 #endif
16641 }
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16649 PyObject *resultobj = 0;
16650 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16651 wxArrayString *result = 0 ;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 PyObject *swig_obj[1] ;
16655
16656 if (!args) SWIG_fail;
16657 swig_obj[0] = args;
16658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16659 if (!SWIG_IsOK(res1)) {
16660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16661 }
16662 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 {
16666 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16667 result = (wxArrayString *) &_result_ref;
16668 }
16669 wxPyEndAllowThreads(__tstate);
16670 if (PyErr_Occurred()) SWIG_fail;
16671 }
16672 {
16673 resultobj = wxArrayString2PyList_helper(*result);
16674 }
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16682 PyObject *resultobj = 0;
16683 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16684 size_t result;
16685 void *argp1 = 0 ;
16686 int res1 = 0 ;
16687 PyObject *swig_obj[1] ;
16688
16689 if (!args) SWIG_fail;
16690 swig_obj[0] = args;
16691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16694 }
16695 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16710 PyObject *resultobj = 0;
16711 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16712 wxString *result = 0 ;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 PyObject *swig_obj[1] ;
16716
16717 if (!args) SWIG_fail;
16718 swig_obj[0] = args;
16719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16722 }
16723 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16724 {
16725 PyThreadState* __tstate = wxPyBeginAllowThreads();
16726 {
16727 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16728 result = (wxString *) &_result_ref;
16729 }
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 {
16734 #if wxUSE_UNICODE
16735 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16736 #else
16737 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16738 #endif
16739 }
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16747 PyObject *resultobj = 0;
16748 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16749 int result;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 PyObject *swig_obj[1] ;
16753
16754 if (!args) SWIG_fail;
16755 swig_obj[0] = args;
16756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16759 }
16760 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 resultobj = SWIG_From_int(static_cast< int >(result));
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16775 PyObject *obj;
16776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16777 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16778 return SWIG_Py_Void();
16779 }
16780
16781 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16782 return SWIG_Python_InitShadowInstance(args);
16783 }
16784
16785 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj = 0;
16787 wxFileTypeInfo *arg1 = 0 ;
16788 wxFileType *result = 0 ;
16789 void *argp1 = 0 ;
16790 int res1 = 0 ;
16791 PyObject * obj0 = 0 ;
16792 char * kwnames[] = {
16793 (char *) "ftInfo", NULL
16794 };
16795
16796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16797 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16798 if (!SWIG_IsOK(res1)) {
16799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16800 }
16801 if (!argp1) {
16802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16803 }
16804 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16819 PyObject *resultobj = 0;
16820 wxFileType *arg1 = (wxFileType *) 0 ;
16821 void *argp1 = 0 ;
16822 int res1 = 0 ;
16823 PyObject *swig_obj[1] ;
16824
16825 if (!args) SWIG_fail;
16826 swig_obj[0] = args;
16827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16828 if (!SWIG_IsOK(res1)) {
16829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16830 }
16831 arg1 = reinterpret_cast< wxFileType * >(argp1);
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 delete arg1;
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 resultobj = SWIG_Py_Void();
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16847 PyObject *resultobj = 0;
16848 wxFileType *arg1 = (wxFileType *) 0 ;
16849 PyObject *result = 0 ;
16850 void *argp1 = 0 ;
16851 int res1 = 0 ;
16852 PyObject *swig_obj[1] ;
16853
16854 if (!args) SWIG_fail;
16855 swig_obj[0] = args;
16856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16859 }
16860 arg1 = reinterpret_cast< wxFileType * >(argp1);
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 result = (PyObject *)wxFileType_GetMimeType(arg1);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 resultobj = result;
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16875 PyObject *resultobj = 0;
16876 wxFileType *arg1 = (wxFileType *) 0 ;
16877 PyObject *result = 0 ;
16878 void *argp1 = 0 ;
16879 int res1 = 0 ;
16880 PyObject *swig_obj[1] ;
16881
16882 if (!args) SWIG_fail;
16883 swig_obj[0] = args;
16884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16885 if (!SWIG_IsOK(res1)) {
16886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16887 }
16888 arg1 = reinterpret_cast< wxFileType * >(argp1);
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 resultobj = result;
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16903 PyObject *resultobj = 0;
16904 wxFileType *arg1 = (wxFileType *) 0 ;
16905 PyObject *result = 0 ;
16906 void *argp1 = 0 ;
16907 int res1 = 0 ;
16908 PyObject *swig_obj[1] ;
16909
16910 if (!args) SWIG_fail;
16911 swig_obj[0] = args;
16912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16913 if (!SWIG_IsOK(res1)) {
16914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16915 }
16916 arg1 = reinterpret_cast< wxFileType * >(argp1);
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 result = (PyObject *)wxFileType_GetExtensions(arg1);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = result;
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931 PyObject *resultobj = 0;
16932 wxFileType *arg1 = (wxFileType *) 0 ;
16933 wxIcon *result = 0 ;
16934 void *argp1 = 0 ;
16935 int res1 = 0 ;
16936 PyObject *swig_obj[1] ;
16937
16938 if (!args) SWIG_fail;
16939 swig_obj[0] = args;
16940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16941 if (!SWIG_IsOK(res1)) {
16942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16943 }
16944 arg1 = reinterpret_cast< wxFileType * >(argp1);
16945 {
16946 PyThreadState* __tstate = wxPyBeginAllowThreads();
16947 result = (wxIcon *)wxFileType_GetIcon(arg1);
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16959 PyObject *resultobj = 0;
16960 wxFileType *arg1 = (wxFileType *) 0 ;
16961 PyObject *result = 0 ;
16962 void *argp1 = 0 ;
16963 int res1 = 0 ;
16964 PyObject *swig_obj[1] ;
16965
16966 if (!args) SWIG_fail;
16967 swig_obj[0] = args;
16968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16969 if (!SWIG_IsOK(res1)) {
16970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16971 }
16972 arg1 = reinterpret_cast< wxFileType * >(argp1);
16973 {
16974 PyThreadState* __tstate = wxPyBeginAllowThreads();
16975 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 resultobj = result;
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16987 PyObject *resultobj = 0;
16988 wxFileType *arg1 = (wxFileType *) 0 ;
16989 PyObject *result = 0 ;
16990 void *argp1 = 0 ;
16991 int res1 = 0 ;
16992 PyObject *swig_obj[1] ;
16993
16994 if (!args) SWIG_fail;
16995 swig_obj[0] = args;
16996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16997 if (!SWIG_IsOK(res1)) {
16998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16999 }
17000 arg1 = reinterpret_cast< wxFileType * >(argp1);
17001 {
17002 PyThreadState* __tstate = wxPyBeginAllowThreads();
17003 result = (PyObject *)wxFileType_GetDescription(arg1);
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 resultobj = result;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj = 0;
17016 wxFileType *arg1 = (wxFileType *) 0 ;
17017 wxString *arg2 = 0 ;
17018 wxString const &arg3_defvalue = wxPyEmptyString ;
17019 wxString *arg3 = (wxString *) &arg3_defvalue ;
17020 PyObject *result = 0 ;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 bool temp2 = false ;
17024 bool temp3 = false ;
17025 PyObject * obj0 = 0 ;
17026 PyObject * obj1 = 0 ;
17027 PyObject * obj2 = 0 ;
17028 char * kwnames[] = {
17029 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17030 };
17031
17032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17034 if (!SWIG_IsOK(res1)) {
17035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17036 }
17037 arg1 = reinterpret_cast< wxFileType * >(argp1);
17038 {
17039 arg2 = wxString_in_helper(obj1);
17040 if (arg2 == NULL) SWIG_fail;
17041 temp2 = true;
17042 }
17043 if (obj2) {
17044 {
17045 arg3 = wxString_in_helper(obj2);
17046 if (arg3 == NULL) SWIG_fail;
17047 temp3 = true;
17048 }
17049 }
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 resultobj = result;
17057 {
17058 if (temp2)
17059 delete arg2;
17060 }
17061 {
17062 if (temp3)
17063 delete arg3;
17064 }
17065 return resultobj;
17066 fail:
17067 {
17068 if (temp2)
17069 delete arg2;
17070 }
17071 {
17072 if (temp3)
17073 delete arg3;
17074 }
17075 return NULL;
17076 }
17077
17078
17079 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17080 PyObject *resultobj = 0;
17081 wxFileType *arg1 = (wxFileType *) 0 ;
17082 wxString *arg2 = 0 ;
17083 wxString const &arg3_defvalue = wxPyEmptyString ;
17084 wxString *arg3 = (wxString *) &arg3_defvalue ;
17085 PyObject *result = 0 ;
17086 void *argp1 = 0 ;
17087 int res1 = 0 ;
17088 bool temp2 = false ;
17089 bool temp3 = false ;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 PyObject * obj2 = 0 ;
17093 char * kwnames[] = {
17094 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17095 };
17096
17097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17099 if (!SWIG_IsOK(res1)) {
17100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17101 }
17102 arg1 = reinterpret_cast< wxFileType * >(argp1);
17103 {
17104 arg2 = wxString_in_helper(obj1);
17105 if (arg2 == NULL) SWIG_fail;
17106 temp2 = true;
17107 }
17108 if (obj2) {
17109 {
17110 arg3 = wxString_in_helper(obj2);
17111 if (arg3 == NULL) SWIG_fail;
17112 temp3 = true;
17113 }
17114 }
17115 {
17116 PyThreadState* __tstate = wxPyBeginAllowThreads();
17117 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 resultobj = result;
17122 {
17123 if (temp2)
17124 delete arg2;
17125 }
17126 {
17127 if (temp3)
17128 delete arg3;
17129 }
17130 return resultobj;
17131 fail:
17132 {
17133 if (temp2)
17134 delete arg2;
17135 }
17136 {
17137 if (temp3)
17138 delete arg3;
17139 }
17140 return NULL;
17141 }
17142
17143
17144 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj = 0;
17146 wxFileType *arg1 = (wxFileType *) 0 ;
17147 wxString *arg2 = 0 ;
17148 wxString const &arg3_defvalue = wxPyEmptyString ;
17149 wxString *arg3 = (wxString *) &arg3_defvalue ;
17150 PyObject *result = 0 ;
17151 void *argp1 = 0 ;
17152 int res1 = 0 ;
17153 bool temp2 = false ;
17154 bool temp3 = false ;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 PyObject * obj2 = 0 ;
17158 char * kwnames[] = {
17159 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17160 };
17161
17162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17164 if (!SWIG_IsOK(res1)) {
17165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17166 }
17167 arg1 = reinterpret_cast< wxFileType * >(argp1);
17168 {
17169 arg2 = wxString_in_helper(obj1);
17170 if (arg2 == NULL) SWIG_fail;
17171 temp2 = true;
17172 }
17173 if (obj2) {
17174 {
17175 arg3 = wxString_in_helper(obj2);
17176 if (arg3 == NULL) SWIG_fail;
17177 temp3 = true;
17178 }
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = result;
17187 {
17188 if (temp2)
17189 delete arg2;
17190 }
17191 {
17192 if (temp3)
17193 delete arg3;
17194 }
17195 return resultobj;
17196 fail:
17197 {
17198 if (temp2)
17199 delete arg2;
17200 }
17201 {
17202 if (temp3)
17203 delete arg3;
17204 }
17205 return NULL;
17206 }
17207
17208
17209 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj = 0;
17211 wxFileType *arg1 = (wxFileType *) 0 ;
17212 wxString *arg2 = 0 ;
17213 wxString *arg3 = 0 ;
17214 bool arg4 = (bool) true ;
17215 bool result;
17216 void *argp1 = 0 ;
17217 int res1 = 0 ;
17218 bool temp2 = false ;
17219 bool temp3 = false ;
17220 bool val4 ;
17221 int ecode4 = 0 ;
17222 PyObject * obj0 = 0 ;
17223 PyObject * obj1 = 0 ;
17224 PyObject * obj2 = 0 ;
17225 PyObject * obj3 = 0 ;
17226 char * kwnames[] = {
17227 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17228 };
17229
17230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17232 if (!SWIG_IsOK(res1)) {
17233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17234 }
17235 arg1 = reinterpret_cast< wxFileType * >(argp1);
17236 {
17237 arg2 = wxString_in_helper(obj1);
17238 if (arg2 == NULL) SWIG_fail;
17239 temp2 = true;
17240 }
17241 {
17242 arg3 = wxString_in_helper(obj2);
17243 if (arg3 == NULL) SWIG_fail;
17244 temp3 = true;
17245 }
17246 if (obj3) {
17247 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17248 if (!SWIG_IsOK(ecode4)) {
17249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17250 }
17251 arg4 = static_cast< bool >(val4);
17252 }
17253 {
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17261 }
17262 {
17263 if (temp2)
17264 delete arg2;
17265 }
17266 {
17267 if (temp3)
17268 delete arg3;
17269 }
17270 return resultobj;
17271 fail:
17272 {
17273 if (temp2)
17274 delete arg2;
17275 }
17276 {
17277 if (temp3)
17278 delete arg3;
17279 }
17280 return NULL;
17281 }
17282
17283
17284 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj = 0;
17286 wxFileType *arg1 = (wxFileType *) 0 ;
17287 wxString const &arg2_defvalue = wxPyEmptyString ;
17288 wxString *arg2 = (wxString *) &arg2_defvalue ;
17289 int arg3 = (int) 0 ;
17290 bool result;
17291 void *argp1 = 0 ;
17292 int res1 = 0 ;
17293 bool temp2 = false ;
17294 int val3 ;
17295 int ecode3 = 0 ;
17296 PyObject * obj0 = 0 ;
17297 PyObject * obj1 = 0 ;
17298 PyObject * obj2 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "self",(char *) "cmd",(char *) "index", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17305 if (!SWIG_IsOK(res1)) {
17306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17307 }
17308 arg1 = reinterpret_cast< wxFileType * >(argp1);
17309 if (obj1) {
17310 {
17311 arg2 = wxString_in_helper(obj1);
17312 if (arg2 == NULL) SWIG_fail;
17313 temp2 = true;
17314 }
17315 }
17316 if (obj2) {
17317 ecode3 = SWIG_AsVal_int(obj2, &val3);
17318 if (!SWIG_IsOK(ecode3)) {
17319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17320 }
17321 arg3 = static_cast< int >(val3);
17322 }
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 {
17330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17331 }
17332 {
17333 if (temp2)
17334 delete arg2;
17335 }
17336 return resultobj;
17337 fail:
17338 {
17339 if (temp2)
17340 delete arg2;
17341 }
17342 return NULL;
17343 }
17344
17345
17346 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *resultobj = 0;
17348 wxFileType *arg1 = (wxFileType *) 0 ;
17349 bool result;
17350 void *argp1 = 0 ;
17351 int res1 = 0 ;
17352 PyObject *swig_obj[1] ;
17353
17354 if (!args) SWIG_fail;
17355 swig_obj[0] = args;
17356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17357 if (!SWIG_IsOK(res1)) {
17358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17359 }
17360 arg1 = reinterpret_cast< wxFileType * >(argp1);
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (bool)(arg1)->Unassociate();
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 {
17368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17369 }
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj = 0;
17378 wxString *arg1 = 0 ;
17379 wxString *arg2 = 0 ;
17380 wxString const &arg3_defvalue = wxPyEmptyString ;
17381 wxString *arg3 = (wxString *) &arg3_defvalue ;
17382 wxString result;
17383 bool temp1 = false ;
17384 bool temp2 = false ;
17385 bool temp3 = false ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 PyObject * obj2 = 0 ;
17389 char * kwnames[] = {
17390 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17391 };
17392
17393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17394 {
17395 arg1 = wxString_in_helper(obj0);
17396 if (arg1 == NULL) SWIG_fail;
17397 temp1 = true;
17398 }
17399 {
17400 arg2 = wxString_in_helper(obj1);
17401 if (arg2 == NULL) SWIG_fail;
17402 temp2 = true;
17403 }
17404 if (obj2) {
17405 {
17406 arg3 = wxString_in_helper(obj2);
17407 if (arg3 == NULL) SWIG_fail;
17408 temp3 = true;
17409 }
17410 }
17411 {
17412 PyThreadState* __tstate = wxPyBeginAllowThreads();
17413 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17414 wxPyEndAllowThreads(__tstate);
17415 if (PyErr_Occurred()) SWIG_fail;
17416 }
17417 {
17418 #if wxUSE_UNICODE
17419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17420 #else
17421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17422 #endif
17423 }
17424 {
17425 if (temp1)
17426 delete arg1;
17427 }
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 {
17433 if (temp3)
17434 delete arg3;
17435 }
17436 return resultobj;
17437 fail:
17438 {
17439 if (temp1)
17440 delete arg1;
17441 }
17442 {
17443 if (temp2)
17444 delete arg2;
17445 }
17446 {
17447 if (temp3)
17448 delete arg3;
17449 }
17450 return NULL;
17451 }
17452
17453
17454 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17455 PyObject *obj;
17456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17457 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17458 return SWIG_Py_Void();
17459 }
17460
17461 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 return SWIG_Python_InitShadowInstance(args);
17463 }
17464
17465 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17466 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17467 return 1;
17468 }
17469
17470
17471 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17472 PyObject *pyobj = 0;
17473
17474 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17475 return pyobj;
17476 }
17477
17478
17479 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj = 0;
17481 wxString *arg1 = 0 ;
17482 wxString *arg2 = 0 ;
17483 bool result;
17484 bool temp1 = false ;
17485 bool temp2 = false ;
17486 PyObject * obj0 = 0 ;
17487 PyObject * obj1 = 0 ;
17488 char * kwnames[] = {
17489 (char *) "mimeType",(char *) "wildcard", NULL
17490 };
17491
17492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17493 {
17494 arg1 = wxString_in_helper(obj0);
17495 if (arg1 == NULL) SWIG_fail;
17496 temp1 = true;
17497 }
17498 {
17499 arg2 = wxString_in_helper(obj1);
17500 if (arg2 == NULL) SWIG_fail;
17501 temp2 = true;
17502 }
17503 {
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 {
17510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17511 }
17512 {
17513 if (temp1)
17514 delete arg1;
17515 }
17516 {
17517 if (temp2)
17518 delete arg2;
17519 }
17520 return resultobj;
17521 fail:
17522 {
17523 if (temp1)
17524 delete arg1;
17525 }
17526 {
17527 if (temp2)
17528 delete arg2;
17529 }
17530 return NULL;
17531 }
17532
17533
17534 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17535 PyObject *resultobj = 0;
17536 wxMimeTypesManager *result = 0 ;
17537
17538 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17539 {
17540 PyThreadState* __tstate = wxPyBeginAllowThreads();
17541 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj = 0;
17554 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17555 int arg2 = (int) wxMAILCAP_ALL ;
17556 wxString const &arg3_defvalue = wxPyEmptyString ;
17557 wxString *arg3 = (wxString *) &arg3_defvalue ;
17558 void *argp1 = 0 ;
17559 int res1 = 0 ;
17560 int val2 ;
17561 int ecode2 = 0 ;
17562 bool temp3 = false ;
17563 PyObject * obj0 = 0 ;
17564 PyObject * obj1 = 0 ;
17565 PyObject * obj2 = 0 ;
17566 char * kwnames[] = {
17567 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17568 };
17569
17570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17572 if (!SWIG_IsOK(res1)) {
17573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17574 }
17575 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17576 if (obj1) {
17577 ecode2 = SWIG_AsVal_int(obj1, &val2);
17578 if (!SWIG_IsOK(ecode2)) {
17579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17580 }
17581 arg2 = static_cast< int >(val2);
17582 }
17583 if (obj2) {
17584 {
17585 arg3 = wxString_in_helper(obj2);
17586 if (arg3 == NULL) SWIG_fail;
17587 temp3 = true;
17588 }
17589 }
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 resultobj = SWIG_Py_Void();
17597 {
17598 if (temp3)
17599 delete arg3;
17600 }
17601 return resultobj;
17602 fail:
17603 {
17604 if (temp3)
17605 delete arg3;
17606 }
17607 return NULL;
17608 }
17609
17610
17611 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17612 PyObject *resultobj = 0;
17613 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17614 void *argp1 = 0 ;
17615 int res1 = 0 ;
17616 PyObject *swig_obj[1] ;
17617
17618 if (!args) SWIG_fail;
17619 swig_obj[0] = args;
17620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17621 if (!SWIG_IsOK(res1)) {
17622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17623 }
17624 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 (arg1)->ClearData();
17628 wxPyEndAllowThreads(__tstate);
17629 if (PyErr_Occurred()) SWIG_fail;
17630 }
17631 resultobj = SWIG_Py_Void();
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17641 wxString *arg2 = 0 ;
17642 wxFileType *result = 0 ;
17643 void *argp1 = 0 ;
17644 int res1 = 0 ;
17645 bool temp2 = false ;
17646 PyObject * obj0 = 0 ;
17647 PyObject * obj1 = 0 ;
17648 char * kwnames[] = {
17649 (char *) "self",(char *) "ext", NULL
17650 };
17651
17652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17654 if (!SWIG_IsOK(res1)) {
17655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17656 }
17657 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17658 {
17659 arg2 = wxString_in_helper(obj1);
17660 if (arg2 == NULL) SWIG_fail;
17661 temp2 = true;
17662 }
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17670 {
17671 if (temp2)
17672 delete arg2;
17673 }
17674 return resultobj;
17675 fail:
17676 {
17677 if (temp2)
17678 delete arg2;
17679 }
17680 return NULL;
17681 }
17682
17683
17684 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17685 PyObject *resultobj = 0;
17686 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17687 wxString *arg2 = 0 ;
17688 wxFileType *result = 0 ;
17689 void *argp1 = 0 ;
17690 int res1 = 0 ;
17691 bool temp2 = false ;
17692 PyObject * obj0 = 0 ;
17693 PyObject * obj1 = 0 ;
17694 char * kwnames[] = {
17695 (char *) "self",(char *) "mimeType", NULL
17696 };
17697
17698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17700 if (!SWIG_IsOK(res1)) {
17701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17702 }
17703 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17704 {
17705 arg2 = wxString_in_helper(obj1);
17706 if (arg2 == NULL) SWIG_fail;
17707 temp2 = true;
17708 }
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17716 {
17717 if (temp2)
17718 delete arg2;
17719 }
17720 return resultobj;
17721 fail:
17722 {
17723 if (temp2)
17724 delete arg2;
17725 }
17726 return NULL;
17727 }
17728
17729
17730 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17731 PyObject *resultobj = 0;
17732 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17733 wxString *arg2 = 0 ;
17734 bool arg3 = (bool) false ;
17735 bool result;
17736 void *argp1 = 0 ;
17737 int res1 = 0 ;
17738 bool temp2 = false ;
17739 bool val3 ;
17740 int ecode3 = 0 ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 PyObject * obj2 = 0 ;
17744 char * kwnames[] = {
17745 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17746 };
17747
17748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17750 if (!SWIG_IsOK(res1)) {
17751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17752 }
17753 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17754 {
17755 arg2 = wxString_in_helper(obj1);
17756 if (arg2 == NULL) SWIG_fail;
17757 temp2 = true;
17758 }
17759 if (obj2) {
17760 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17761 if (!SWIG_IsOK(ecode3)) {
17762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17763 }
17764 arg3 = static_cast< bool >(val3);
17765 }
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17769 wxPyEndAllowThreads(__tstate);
17770 if (PyErr_Occurred()) SWIG_fail;
17771 }
17772 {
17773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17774 }
17775 {
17776 if (temp2)
17777 delete arg2;
17778 }
17779 return resultobj;
17780 fail:
17781 {
17782 if (temp2)
17783 delete arg2;
17784 }
17785 return NULL;
17786 }
17787
17788
17789 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = 0;
17791 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17792 wxString *arg2 = 0 ;
17793 bool result;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 bool temp2 = false ;
17797 PyObject * obj0 = 0 ;
17798 PyObject * obj1 = 0 ;
17799 char * kwnames[] = {
17800 (char *) "self",(char *) "filename", NULL
17801 };
17802
17803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17805 if (!SWIG_IsOK(res1)) {
17806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17807 }
17808 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17809 {
17810 arg2 = wxString_in_helper(obj1);
17811 if (arg2 == NULL) SWIG_fail;
17812 temp2 = true;
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 {
17824 if (temp2)
17825 delete arg2;
17826 }
17827 return resultobj;
17828 fail:
17829 {
17830 if (temp2)
17831 delete arg2;
17832 }
17833 return NULL;
17834 }
17835
17836
17837 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17838 PyObject *resultobj = 0;
17839 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17840 PyObject *result = 0 ;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 PyObject *swig_obj[1] ;
17844
17845 if (!args) SWIG_fail;
17846 swig_obj[0] = args;
17847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17848 if (!SWIG_IsOK(res1)) {
17849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17850 }
17851 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 resultobj = result;
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj = 0;
17867 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17868 wxFileTypeInfo *arg2 = 0 ;
17869 void *argp1 = 0 ;
17870 int res1 = 0 ;
17871 void *argp2 = 0 ;
17872 int res2 = 0 ;
17873 PyObject * obj0 = 0 ;
17874 PyObject * obj1 = 0 ;
17875 char * kwnames[] = {
17876 (char *) "self",(char *) "ft", NULL
17877 };
17878
17879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17881 if (!SWIG_IsOK(res1)) {
17882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17883 }
17884 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17886 if (!SWIG_IsOK(res2)) {
17887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17888 }
17889 if (!argp2) {
17890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17891 }
17892 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 resultobj = SWIG_Py_Void();
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj = 0;
17908 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17909 wxFileTypeInfo *arg2 = 0 ;
17910 wxFileType *result = 0 ;
17911 void *argp1 = 0 ;
17912 int res1 = 0 ;
17913 void *argp2 = 0 ;
17914 int res2 = 0 ;
17915 PyObject * obj0 = 0 ;
17916 PyObject * obj1 = 0 ;
17917 char * kwnames[] = {
17918 (char *) "self",(char *) "ftInfo", NULL
17919 };
17920
17921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17923 if (!SWIG_IsOK(res1)) {
17924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17925 }
17926 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17928 if (!SWIG_IsOK(res2)) {
17929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17930 }
17931 if (!argp2) {
17932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17933 }
17934 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17938 wxPyEndAllowThreads(__tstate);
17939 if (PyErr_Occurred()) SWIG_fail;
17940 }
17941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj = 0;
17950 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17951 wxFileType *arg2 = (wxFileType *) 0 ;
17952 bool result;
17953 void *argp1 = 0 ;
17954 int res1 = 0 ;
17955 void *argp2 = 0 ;
17956 int res2 = 0 ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 char * kwnames[] = {
17960 (char *) "self",(char *) "ft", NULL
17961 };
17962
17963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17965 if (!SWIG_IsOK(res1)) {
17966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17967 }
17968 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17969 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17970 if (!SWIG_IsOK(res2)) {
17971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17972 }
17973 arg2 = reinterpret_cast< wxFileType * >(argp2);
17974 {
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 result = (bool)(arg1)->Unassociate(arg2);
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 {
17981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17982 }
17983 return resultobj;
17984 fail:
17985 return NULL;
17986 }
17987
17988
17989 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 PyObject *resultobj = 0;
17991 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17992 void *argp1 = 0 ;
17993 int res1 = 0 ;
17994 PyObject *swig_obj[1] ;
17995
17996 if (!args) SWIG_fail;
17997 swig_obj[0] = args;
17998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17999 if (!SWIG_IsOK(res1)) {
18000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18001 }
18002 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 delete arg1;
18006
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 resultobj = SWIG_Py_Void();
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *obj;
18019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18020 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18021 return SWIG_Py_Void();
18022 }
18023
18024 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18025 return SWIG_Python_InitShadowInstance(args);
18026 }
18027
18028 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18029 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18030 return 1;
18031 }
18032
18033
18034 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18035 PyObject *pyobj = 0;
18036
18037 {
18038 #if wxUSE_UNICODE
18039 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18040 #else
18041 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18042 #endif
18043 }
18044 return pyobj;
18045 }
18046
18047
18048 SWIGINTERN int ART_MENU_set(PyObject *) {
18049 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18050 return 1;
18051 }
18052
18053
18054 SWIGINTERN PyObject *ART_MENU_get(void) {
18055 PyObject *pyobj = 0;
18056
18057 {
18058 #if wxUSE_UNICODE
18059 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18060 #else
18061 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18062 #endif
18063 }
18064 return pyobj;
18065 }
18066
18067
18068 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18069 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18070 return 1;
18071 }
18072
18073
18074 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18075 PyObject *pyobj = 0;
18076
18077 {
18078 #if wxUSE_UNICODE
18079 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18080 #else
18081 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18082 #endif
18083 }
18084 return pyobj;
18085 }
18086
18087
18088 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18089 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18090 return 1;
18091 }
18092
18093
18094 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18095 PyObject *pyobj = 0;
18096
18097 {
18098 #if wxUSE_UNICODE
18099 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18100 #else
18101 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18102 #endif
18103 }
18104 return pyobj;
18105 }
18106
18107
18108 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18109 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18110 return 1;
18111 }
18112
18113
18114 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18115 PyObject *pyobj = 0;
18116
18117 {
18118 #if wxUSE_UNICODE
18119 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18120 #else
18121 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18122 #endif
18123 }
18124 return pyobj;
18125 }
18126
18127
18128 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18129 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18130 return 1;
18131 }
18132
18133
18134 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18135 PyObject *pyobj = 0;
18136
18137 {
18138 #if wxUSE_UNICODE
18139 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18140 #else
18141 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18142 #endif
18143 }
18144 return pyobj;
18145 }
18146
18147
18148 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18149 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18150 return 1;
18151 }
18152
18153
18154 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18155 PyObject *pyobj = 0;
18156
18157 {
18158 #if wxUSE_UNICODE
18159 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18160 #else
18161 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18162 #endif
18163 }
18164 return pyobj;
18165 }
18166
18167
18168 SWIGINTERN int ART_OTHER_set(PyObject *) {
18169 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18170 return 1;
18171 }
18172
18173
18174 SWIGINTERN PyObject *ART_OTHER_get(void) {
18175 PyObject *pyobj = 0;
18176
18177 {
18178 #if wxUSE_UNICODE
18179 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18180 #else
18181 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18182 #endif
18183 }
18184 return pyobj;
18185 }
18186
18187
18188 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18189 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18190 return 1;
18191 }
18192
18193
18194 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18195 PyObject *pyobj = 0;
18196
18197 {
18198 #if wxUSE_UNICODE
18199 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18200 #else
18201 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18202 #endif
18203 }
18204 return pyobj;
18205 }
18206
18207
18208 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18209 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18210 return 1;
18211 }
18212
18213
18214 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18215 PyObject *pyobj = 0;
18216
18217 {
18218 #if wxUSE_UNICODE
18219 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18220 #else
18221 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18222 #endif
18223 }
18224 return pyobj;
18225 }
18226
18227
18228 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18229 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18230 return 1;
18231 }
18232
18233
18234 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18235 PyObject *pyobj = 0;
18236
18237 {
18238 #if wxUSE_UNICODE
18239 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18240 #else
18241 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18242 #endif
18243 }
18244 return pyobj;
18245 }
18246
18247
18248 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18249 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18250 return 1;
18251 }
18252
18253
18254 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18255 PyObject *pyobj = 0;
18256
18257 {
18258 #if wxUSE_UNICODE
18259 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18260 #else
18261 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18262 #endif
18263 }
18264 return pyobj;
18265 }
18266
18267
18268 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18269 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18270 return 1;
18271 }
18272
18273
18274 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18275 PyObject *pyobj = 0;
18276
18277 {
18278 #if wxUSE_UNICODE
18279 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18280 #else
18281 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18282 #endif
18283 }
18284 return pyobj;
18285 }
18286
18287
18288 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18289 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18290 return 1;
18291 }
18292
18293
18294 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18295 PyObject *pyobj = 0;
18296
18297 {
18298 #if wxUSE_UNICODE
18299 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18300 #else
18301 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18302 #endif
18303 }
18304 return pyobj;
18305 }
18306
18307
18308 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18309 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18310 return 1;
18311 }
18312
18313
18314 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18315 PyObject *pyobj = 0;
18316
18317 {
18318 #if wxUSE_UNICODE
18319 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18320 #else
18321 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18322 #endif
18323 }
18324 return pyobj;
18325 }
18326
18327
18328 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18329 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18330 return 1;
18331 }
18332
18333
18334 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18335 PyObject *pyobj = 0;
18336
18337 {
18338 #if wxUSE_UNICODE
18339 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18340 #else
18341 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18342 #endif
18343 }
18344 return pyobj;
18345 }
18346
18347
18348 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18349 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18350 return 1;
18351 }
18352
18353
18354 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18355 PyObject *pyobj = 0;
18356
18357 {
18358 #if wxUSE_UNICODE
18359 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18360 #else
18361 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18362 #endif
18363 }
18364 return pyobj;
18365 }
18366
18367
18368 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18369 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18370 return 1;
18371 }
18372
18373
18374 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18375 PyObject *pyobj = 0;
18376
18377 {
18378 #if wxUSE_UNICODE
18379 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18380 #else
18381 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18382 #endif
18383 }
18384 return pyobj;
18385 }
18386
18387
18388 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18389 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18390 return 1;
18391 }
18392
18393
18394 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18395 PyObject *pyobj = 0;
18396
18397 {
18398 #if wxUSE_UNICODE
18399 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18400 #else
18401 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18402 #endif
18403 }
18404 return pyobj;
18405 }
18406
18407
18408 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18409 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18410 return 1;
18411 }
18412
18413
18414 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18415 PyObject *pyobj = 0;
18416
18417 {
18418 #if wxUSE_UNICODE
18419 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18420 #else
18421 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18422 #endif
18423 }
18424 return pyobj;
18425 }
18426
18427
18428 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18429 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18430 return 1;
18431 }
18432
18433
18434 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18435 PyObject *pyobj = 0;
18436
18437 {
18438 #if wxUSE_UNICODE
18439 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18440 #else
18441 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18442 #endif
18443 }
18444 return pyobj;
18445 }
18446
18447
18448 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18449 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18450 return 1;
18451 }
18452
18453
18454 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18455 PyObject *pyobj = 0;
18456
18457 {
18458 #if wxUSE_UNICODE
18459 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18460 #else
18461 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18462 #endif
18463 }
18464 return pyobj;
18465 }
18466
18467
18468 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18469 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18470 return 1;
18471 }
18472
18473
18474 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18475 PyObject *pyobj = 0;
18476
18477 {
18478 #if wxUSE_UNICODE
18479 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18480 #else
18481 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18482 #endif
18483 }
18484 return pyobj;
18485 }
18486
18487
18488 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18489 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18490 return 1;
18491 }
18492
18493
18494 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18495 PyObject *pyobj = 0;
18496
18497 {
18498 #if wxUSE_UNICODE
18499 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18500 #else
18501 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18502 #endif
18503 }
18504 return pyobj;
18505 }
18506
18507
18508 SWIGINTERN int ART_PRINT_set(PyObject *) {
18509 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18510 return 1;
18511 }
18512
18513
18514 SWIGINTERN PyObject *ART_PRINT_get(void) {
18515 PyObject *pyobj = 0;
18516
18517 {
18518 #if wxUSE_UNICODE
18519 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18520 #else
18521 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18522 #endif
18523 }
18524 return pyobj;
18525 }
18526
18527
18528 SWIGINTERN int ART_HELP_set(PyObject *) {
18529 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18530 return 1;
18531 }
18532
18533
18534 SWIGINTERN PyObject *ART_HELP_get(void) {
18535 PyObject *pyobj = 0;
18536
18537 {
18538 #if wxUSE_UNICODE
18539 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18540 #else
18541 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18542 #endif
18543 }
18544 return pyobj;
18545 }
18546
18547
18548 SWIGINTERN int ART_TIP_set(PyObject *) {
18549 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18550 return 1;
18551 }
18552
18553
18554 SWIGINTERN PyObject *ART_TIP_get(void) {
18555 PyObject *pyobj = 0;
18556
18557 {
18558 #if wxUSE_UNICODE
18559 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18560 #else
18561 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18562 #endif
18563 }
18564 return pyobj;
18565 }
18566
18567
18568 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18569 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18570 return 1;
18571 }
18572
18573
18574 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18575 PyObject *pyobj = 0;
18576
18577 {
18578 #if wxUSE_UNICODE
18579 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18580 #else
18581 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18582 #endif
18583 }
18584 return pyobj;
18585 }
18586
18587
18588 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18589 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18590 return 1;
18591 }
18592
18593
18594 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18595 PyObject *pyobj = 0;
18596
18597 {
18598 #if wxUSE_UNICODE
18599 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18600 #else
18601 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18602 #endif
18603 }
18604 return pyobj;
18605 }
18606
18607
18608 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18609 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18610 return 1;
18611 }
18612
18613
18614 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18615 PyObject *pyobj = 0;
18616
18617 {
18618 #if wxUSE_UNICODE
18619 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18620 #else
18621 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18622 #endif
18623 }
18624 return pyobj;
18625 }
18626
18627
18628 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18629 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18630 return 1;
18631 }
18632
18633
18634 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18635 PyObject *pyobj = 0;
18636
18637 {
18638 #if wxUSE_UNICODE
18639 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18640 #else
18641 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18642 #endif
18643 }
18644 return pyobj;
18645 }
18646
18647
18648 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18649 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18650 return 1;
18651 }
18652
18653
18654 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18655 PyObject *pyobj = 0;
18656
18657 {
18658 #if wxUSE_UNICODE
18659 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18660 #else
18661 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18662 #endif
18663 }
18664 return pyobj;
18665 }
18666
18667
18668 SWIGINTERN int ART_CDROM_set(PyObject *) {
18669 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18670 return 1;
18671 }
18672
18673
18674 SWIGINTERN PyObject *ART_CDROM_get(void) {
18675 PyObject *pyobj = 0;
18676
18677 {
18678 #if wxUSE_UNICODE
18679 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18680 #else
18681 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18682 #endif
18683 }
18684 return pyobj;
18685 }
18686
18687
18688 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18689 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18690 return 1;
18691 }
18692
18693
18694 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18695 PyObject *pyobj = 0;
18696
18697 {
18698 #if wxUSE_UNICODE
18699 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18700 #else
18701 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18702 #endif
18703 }
18704 return pyobj;
18705 }
18706
18707
18708 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18709 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18710 return 1;
18711 }
18712
18713
18714 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18715 PyObject *pyobj = 0;
18716
18717 {
18718 #if wxUSE_UNICODE
18719 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18720 #else
18721 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18722 #endif
18723 }
18724 return pyobj;
18725 }
18726
18727
18728 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18729 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18730 return 1;
18731 }
18732
18733
18734 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18735 PyObject *pyobj = 0;
18736
18737 {
18738 #if wxUSE_UNICODE
18739 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18740 #else
18741 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18742 #endif
18743 }
18744 return pyobj;
18745 }
18746
18747
18748 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18749 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18750 return 1;
18751 }
18752
18753
18754 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18755 PyObject *pyobj = 0;
18756
18757 {
18758 #if wxUSE_UNICODE
18759 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18760 #else
18761 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18762 #endif
18763 }
18764 return pyobj;
18765 }
18766
18767
18768 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18769 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18770 return 1;
18771 }
18772
18773
18774 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18775 PyObject *pyobj = 0;
18776
18777 {
18778 #if wxUSE_UNICODE
18779 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18780 #else
18781 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18782 #endif
18783 }
18784 return pyobj;
18785 }
18786
18787
18788 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18789 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18790 return 1;
18791 }
18792
18793
18794 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18795 PyObject *pyobj = 0;
18796
18797 {
18798 #if wxUSE_UNICODE
18799 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18800 #else
18801 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18802 #endif
18803 }
18804 return pyobj;
18805 }
18806
18807
18808 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18809 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18810 return 1;
18811 }
18812
18813
18814 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18815 PyObject *pyobj = 0;
18816
18817 {
18818 #if wxUSE_UNICODE
18819 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18820 #else
18821 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18822 #endif
18823 }
18824 return pyobj;
18825 }
18826
18827
18828 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18829 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18830 return 1;
18831 }
18832
18833
18834 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18835 PyObject *pyobj = 0;
18836
18837 {
18838 #if wxUSE_UNICODE
18839 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18840 #else
18841 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18842 #endif
18843 }
18844 return pyobj;
18845 }
18846
18847
18848 SWIGINTERN int ART_ERROR_set(PyObject *) {
18849 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18850 return 1;
18851 }
18852
18853
18854 SWIGINTERN PyObject *ART_ERROR_get(void) {
18855 PyObject *pyobj = 0;
18856
18857 {
18858 #if wxUSE_UNICODE
18859 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18860 #else
18861 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18862 #endif
18863 }
18864 return pyobj;
18865 }
18866
18867
18868 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18869 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18870 return 1;
18871 }
18872
18873
18874 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18875 PyObject *pyobj = 0;
18876
18877 {
18878 #if wxUSE_UNICODE
18879 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18880 #else
18881 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18882 #endif
18883 }
18884 return pyobj;
18885 }
18886
18887
18888 SWIGINTERN int ART_WARNING_set(PyObject *) {
18889 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18890 return 1;
18891 }
18892
18893
18894 SWIGINTERN PyObject *ART_WARNING_get(void) {
18895 PyObject *pyobj = 0;
18896
18897 {
18898 #if wxUSE_UNICODE
18899 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18900 #else
18901 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18902 #endif
18903 }
18904 return pyobj;
18905 }
18906
18907
18908 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18909 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18910 return 1;
18911 }
18912
18913
18914 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18915 PyObject *pyobj = 0;
18916
18917 {
18918 #if wxUSE_UNICODE
18919 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18920 #else
18921 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18922 #endif
18923 }
18924 return pyobj;
18925 }
18926
18927
18928 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18929 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18930 return 1;
18931 }
18932
18933
18934 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18935 PyObject *pyobj = 0;
18936
18937 {
18938 #if wxUSE_UNICODE
18939 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18940 #else
18941 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18942 #endif
18943 }
18944 return pyobj;
18945 }
18946
18947
18948 SWIGINTERN int ART_COPY_set(PyObject *) {
18949 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18950 return 1;
18951 }
18952
18953
18954 SWIGINTERN PyObject *ART_COPY_get(void) {
18955 PyObject *pyobj = 0;
18956
18957 {
18958 #if wxUSE_UNICODE
18959 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18960 #else
18961 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18962 #endif
18963 }
18964 return pyobj;
18965 }
18966
18967
18968 SWIGINTERN int ART_CUT_set(PyObject *) {
18969 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18970 return 1;
18971 }
18972
18973
18974 SWIGINTERN PyObject *ART_CUT_get(void) {
18975 PyObject *pyobj = 0;
18976
18977 {
18978 #if wxUSE_UNICODE
18979 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18980 #else
18981 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18982 #endif
18983 }
18984 return pyobj;
18985 }
18986
18987
18988 SWIGINTERN int ART_PASTE_set(PyObject *) {
18989 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18990 return 1;
18991 }
18992
18993
18994 SWIGINTERN PyObject *ART_PASTE_get(void) {
18995 PyObject *pyobj = 0;
18996
18997 {
18998 #if wxUSE_UNICODE
18999 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19000 #else
19001 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19002 #endif
19003 }
19004 return pyobj;
19005 }
19006
19007
19008 SWIGINTERN int ART_DELETE_set(PyObject *) {
19009 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19010 return 1;
19011 }
19012
19013
19014 SWIGINTERN PyObject *ART_DELETE_get(void) {
19015 PyObject *pyobj = 0;
19016
19017 {
19018 #if wxUSE_UNICODE
19019 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19020 #else
19021 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19022 #endif
19023 }
19024 return pyobj;
19025 }
19026
19027
19028 SWIGINTERN int ART_NEW_set(PyObject *) {
19029 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19030 return 1;
19031 }
19032
19033
19034 SWIGINTERN PyObject *ART_NEW_get(void) {
19035 PyObject *pyobj = 0;
19036
19037 {
19038 #if wxUSE_UNICODE
19039 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19040 #else
19041 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19042 #endif
19043 }
19044 return pyobj;
19045 }
19046
19047
19048 SWIGINTERN int ART_UNDO_set(PyObject *) {
19049 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19050 return 1;
19051 }
19052
19053
19054 SWIGINTERN PyObject *ART_UNDO_get(void) {
19055 PyObject *pyobj = 0;
19056
19057 {
19058 #if wxUSE_UNICODE
19059 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19060 #else
19061 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19062 #endif
19063 }
19064 return pyobj;
19065 }
19066
19067
19068 SWIGINTERN int ART_REDO_set(PyObject *) {
19069 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19070 return 1;
19071 }
19072
19073
19074 SWIGINTERN PyObject *ART_REDO_get(void) {
19075 PyObject *pyobj = 0;
19076
19077 {
19078 #if wxUSE_UNICODE
19079 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19080 #else
19081 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19082 #endif
19083 }
19084 return pyobj;
19085 }
19086
19087
19088 SWIGINTERN int ART_QUIT_set(PyObject *) {
19089 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19090 return 1;
19091 }
19092
19093
19094 SWIGINTERN PyObject *ART_QUIT_get(void) {
19095 PyObject *pyobj = 0;
19096
19097 {
19098 #if wxUSE_UNICODE
19099 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19100 #else
19101 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19102 #endif
19103 }
19104 return pyobj;
19105 }
19106
19107
19108 SWIGINTERN int ART_FIND_set(PyObject *) {
19109 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19110 return 1;
19111 }
19112
19113
19114 SWIGINTERN PyObject *ART_FIND_get(void) {
19115 PyObject *pyobj = 0;
19116
19117 {
19118 #if wxUSE_UNICODE
19119 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19120 #else
19121 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19122 #endif
19123 }
19124 return pyobj;
19125 }
19126
19127
19128 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19129 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19130 return 1;
19131 }
19132
19133
19134 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19135 PyObject *pyobj = 0;
19136
19137 {
19138 #if wxUSE_UNICODE
19139 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19140 #else
19141 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19142 #endif
19143 }
19144 return pyobj;
19145 }
19146
19147
19148 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19149 PyObject *resultobj = 0;
19150 wxPyArtProvider *result = 0 ;
19151
19152 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19153 {
19154 if (!wxPyCheckForApp()) SWIG_fail;
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (wxPyArtProvider *)new wxPyArtProvider();
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19161 return resultobj;
19162 fail:
19163 return NULL;
19164 }
19165
19166
19167 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19168 PyObject *resultobj = 0;
19169 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 PyObject *swig_obj[1] ;
19173
19174 if (!args) SWIG_fail;
19175 swig_obj[0] = args;
19176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19179 }
19180 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 delete arg1;
19184
19185 wxPyEndAllowThreads(__tstate);
19186 if (PyErr_Occurred()) SWIG_fail;
19187 }
19188 resultobj = SWIG_Py_Void();
19189 return resultobj;
19190 fail:
19191 return NULL;
19192 }
19193
19194
19195 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj = 0;
19197 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19198 PyObject *arg2 = (PyObject *) 0 ;
19199 PyObject *arg3 = (PyObject *) 0 ;
19200 void *argp1 = 0 ;
19201 int res1 = 0 ;
19202 PyObject * obj0 = 0 ;
19203 PyObject * obj1 = 0 ;
19204 PyObject * obj2 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "self",(char *) "self",(char *) "_class", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19213 }
19214 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19215 arg2 = obj1;
19216 arg3 = obj2;
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 (arg1)->_setCallbackInfo(arg2,arg3);
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_Py_Void();
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19231 PyObject *resultobj = 0;
19232 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19233 int res1 = 0 ;
19234 PyObject * obj0 = 0 ;
19235 char * kwnames[] = {
19236 (char *) "provider", NULL
19237 };
19238
19239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19240 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19241 if (!SWIG_IsOK(res1)) {
19242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19243 }
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 wxPyArtProvider::PushProvider(arg1);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = SWIG_Py_Void();
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 PyObject *resultobj = 0;
19259 bool result;
19260
19261 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 result = (bool)wxPyArtProvider::PopProvider();
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj = 0;
19279 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19280 bool result;
19281 void *argp1 = 0 ;
19282 int res1 = 0 ;
19283 PyObject * obj0 = 0 ;
19284 char * kwnames[] = {
19285 (char *) "provider", NULL
19286 };
19287
19288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19290 if (!SWIG_IsOK(res1)) {
19291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19292 }
19293 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19297 wxPyEndAllowThreads(__tstate);
19298 if (PyErr_Occurred()) SWIG_fail;
19299 }
19300 {
19301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19302 }
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19310 PyObject *resultobj = 0;
19311 wxString *arg1 = 0 ;
19312 wxString const &arg2_defvalue = wxPyART_OTHER ;
19313 wxString *arg2 = (wxString *) &arg2_defvalue ;
19314 wxSize const &arg3_defvalue = wxDefaultSize ;
19315 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19316 wxBitmap result;
19317 bool temp1 = false ;
19318 bool temp2 = false ;
19319 wxSize temp3 ;
19320 PyObject * obj0 = 0 ;
19321 PyObject * obj1 = 0 ;
19322 PyObject * obj2 = 0 ;
19323 char * kwnames[] = {
19324 (char *) "id",(char *) "client",(char *) "size", NULL
19325 };
19326
19327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19328 {
19329 arg1 = wxString_in_helper(obj0);
19330 if (arg1 == NULL) SWIG_fail;
19331 temp1 = true;
19332 }
19333 if (obj1) {
19334 {
19335 arg2 = wxString_in_helper(obj1);
19336 if (arg2 == NULL) SWIG_fail;
19337 temp2 = true;
19338 }
19339 }
19340 if (obj2) {
19341 {
19342 arg3 = &temp3;
19343 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19344 }
19345 }
19346 {
19347 if (!wxPyCheckForApp()) SWIG_fail;
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19354 {
19355 if (temp1)
19356 delete arg1;
19357 }
19358 {
19359 if (temp2)
19360 delete arg2;
19361 }
19362 return resultobj;
19363 fail:
19364 {
19365 if (temp1)
19366 delete arg1;
19367 }
19368 {
19369 if (temp2)
19370 delete arg2;
19371 }
19372 return NULL;
19373 }
19374
19375
19376 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj = 0;
19378 wxString *arg1 = 0 ;
19379 wxString const &arg2_defvalue = wxPyART_OTHER ;
19380 wxString *arg2 = (wxString *) &arg2_defvalue ;
19381 wxSize const &arg3_defvalue = wxDefaultSize ;
19382 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19383 wxIcon result;
19384 bool temp1 = false ;
19385 bool temp2 = false ;
19386 wxSize temp3 ;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 PyObject * obj2 = 0 ;
19390 char * kwnames[] = {
19391 (char *) "id",(char *) "client",(char *) "size", NULL
19392 };
19393
19394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19395 {
19396 arg1 = wxString_in_helper(obj0);
19397 if (arg1 == NULL) SWIG_fail;
19398 temp1 = true;
19399 }
19400 if (obj1) {
19401 {
19402 arg2 = wxString_in_helper(obj1);
19403 if (arg2 == NULL) SWIG_fail;
19404 temp2 = true;
19405 }
19406 }
19407 if (obj2) {
19408 {
19409 arg3 = &temp3;
19410 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19411 }
19412 }
19413 {
19414 if (!wxPyCheckForApp()) SWIG_fail;
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19421 {
19422 if (temp1)
19423 delete arg1;
19424 }
19425 {
19426 if (temp2)
19427 delete arg2;
19428 }
19429 return resultobj;
19430 fail:
19431 {
19432 if (temp1)
19433 delete arg1;
19434 }
19435 {
19436 if (temp2)
19437 delete arg2;
19438 }
19439 return NULL;
19440 }
19441
19442
19443 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj = 0;
19445 wxString *arg1 = 0 ;
19446 bool arg2 = (bool) false ;
19447 wxSize result;
19448 bool temp1 = false ;
19449 bool val2 ;
19450 int ecode2 = 0 ;
19451 PyObject * obj0 = 0 ;
19452 PyObject * obj1 = 0 ;
19453 char * kwnames[] = {
19454 (char *) "client",(char *) "platform_dependent", NULL
19455 };
19456
19457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19458 {
19459 arg1 = wxString_in_helper(obj0);
19460 if (arg1 == NULL) SWIG_fail;
19461 temp1 = true;
19462 }
19463 if (obj1) {
19464 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19465 if (!SWIG_IsOK(ecode2)) {
19466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19467 }
19468 arg2 = static_cast< bool >(val2);
19469 }
19470 {
19471 PyThreadState* __tstate = wxPyBeginAllowThreads();
19472 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19477 {
19478 if (temp1)
19479 delete arg1;
19480 }
19481 return resultobj;
19482 fail:
19483 {
19484 if (temp1)
19485 delete arg1;
19486 }
19487 return NULL;
19488 }
19489
19490
19491 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19492 PyObject *resultobj = 0;
19493 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19494 void *argp1 = 0 ;
19495 int res1 = 0 ;
19496 PyObject *swig_obj[1] ;
19497
19498 if (!args) SWIG_fail;
19499 swig_obj[0] = args;
19500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19501 if (!SWIG_IsOK(res1)) {
19502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19503 }
19504 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 wxPyArtProvider_Destroy(arg1);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19519 PyObject *obj;
19520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19521 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19522 return SWIG_Py_Void();
19523 }
19524
19525 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19526 return SWIG_Python_InitShadowInstance(args);
19527 }
19528
19529 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19530 PyObject *resultobj = 0;
19531 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19532 void *argp1 = 0 ;
19533 int res1 = 0 ;
19534 PyObject *swig_obj[1] ;
19535
19536 if (!args) SWIG_fail;
19537 swig_obj[0] = args;
19538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19539 if (!SWIG_IsOK(res1)) {
19540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19541 }
19542 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 delete arg1;
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 resultobj = SWIG_Py_Void();
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19558 PyObject *resultobj = 0;
19559 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19560 wxConfigBase *result = 0 ;
19561 int res1 = 0 ;
19562 PyObject * obj0 = 0 ;
19563 char * kwnames[] = {
19564 (char *) "config", NULL
19565 };
19566
19567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19568 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19569 if (!SWIG_IsOK(res1)) {
19570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19571 }
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj = 0;
19587 bool arg1 = (bool) true ;
19588 wxConfigBase *result = 0 ;
19589 bool val1 ;
19590 int ecode1 = 0 ;
19591 PyObject * obj0 = 0 ;
19592 char * kwnames[] = {
19593 (char *) "createOnDemand", NULL
19594 };
19595
19596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19597 if (obj0) {
19598 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19599 if (!SWIG_IsOK(ecode1)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19601 }
19602 arg1 = static_cast< bool >(val1);
19603 }
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19618 PyObject *resultobj = 0;
19619 wxConfigBase *result = 0 ;
19620
19621 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (wxConfigBase *)wxConfigBase::Create();
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19636 PyObject *resultobj = 0;
19637
19638 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 wxConfigBase::DontCreateOnDemand();
19642 wxPyEndAllowThreads(__tstate);
19643 if (PyErr_Occurred()) SWIG_fail;
19644 }
19645 resultobj = SWIG_Py_Void();
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19653 PyObject *resultobj = 0;
19654 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19655 wxString *arg2 = 0 ;
19656 void *argp1 = 0 ;
19657 int res1 = 0 ;
19658 bool temp2 = false ;
19659 PyObject * obj0 = 0 ;
19660 PyObject * obj1 = 0 ;
19661 char * kwnames[] = {
19662 (char *) "self",(char *) "path", NULL
19663 };
19664
19665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19669 }
19670 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19671 {
19672 arg2 = wxString_in_helper(obj1);
19673 if (arg2 == NULL) SWIG_fail;
19674 temp2 = true;
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 (arg1)->SetPath((wxString const &)*arg2);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_Py_Void();
19683 {
19684 if (temp2)
19685 delete arg2;
19686 }
19687 return resultobj;
19688 fail:
19689 {
19690 if (temp2)
19691 delete arg2;
19692 }
19693 return NULL;
19694 }
19695
19696
19697 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19698 PyObject *resultobj = 0;
19699 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19700 wxString *result = 0 ;
19701 void *argp1 = 0 ;
19702 int res1 = 0 ;
19703 PyObject *swig_obj[1] ;
19704
19705 if (!args) SWIG_fail;
19706 swig_obj[0] = args;
19707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19708 if (!SWIG_IsOK(res1)) {
19709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19710 }
19711 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19712 {
19713 PyThreadState* __tstate = wxPyBeginAllowThreads();
19714 {
19715 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19716 result = (wxString *) &_result_ref;
19717 }
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 #if wxUSE_UNICODE
19723 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19724 #else
19725 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19726 #endif
19727 }
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 PyObject *resultobj = 0;
19736 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19737 PyObject *result = 0 ;
19738 void *argp1 = 0 ;
19739 int res1 = 0 ;
19740 PyObject *swig_obj[1] ;
19741
19742 if (!args) SWIG_fail;
19743 swig_obj[0] = args;
19744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19745 if (!SWIG_IsOK(res1)) {
19746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19747 }
19748 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 resultobj = result;
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19763 PyObject *resultobj = 0;
19764 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19765 long arg2 ;
19766 PyObject *result = 0 ;
19767 void *argp1 = 0 ;
19768 int res1 = 0 ;
19769 long val2 ;
19770 int ecode2 = 0 ;
19771 PyObject * obj0 = 0 ;
19772 PyObject * obj1 = 0 ;
19773 char * kwnames[] = {
19774 (char *) "self",(char *) "index", NULL
19775 };
19776
19777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19779 if (!SWIG_IsOK(res1)) {
19780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19781 }
19782 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19783 ecode2 = SWIG_AsVal_long(obj1, &val2);
19784 if (!SWIG_IsOK(ecode2)) {
19785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19786 }
19787 arg2 = static_cast< long >(val2);
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = result;
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19802 PyObject *resultobj = 0;
19803 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19804 PyObject *result = 0 ;
19805 void *argp1 = 0 ;
19806 int res1 = 0 ;
19807 PyObject *swig_obj[1] ;
19808
19809 if (!args) SWIG_fail;
19810 swig_obj[0] = args;
19811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19812 if (!SWIG_IsOK(res1)) {
19813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19814 }
19815 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19816 {
19817 PyThreadState* __tstate = wxPyBeginAllowThreads();
19818 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 resultobj = result;
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19830 PyObject *resultobj = 0;
19831 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19832 long arg2 ;
19833 PyObject *result = 0 ;
19834 void *argp1 = 0 ;
19835 int res1 = 0 ;
19836 long val2 ;
19837 int ecode2 = 0 ;
19838 PyObject * obj0 = 0 ;
19839 PyObject * obj1 = 0 ;
19840 char * kwnames[] = {
19841 (char *) "self",(char *) "index", NULL
19842 };
19843
19844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19846 if (!SWIG_IsOK(res1)) {
19847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19848 }
19849 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19850 ecode2 = SWIG_AsVal_long(obj1, &val2);
19851 if (!SWIG_IsOK(ecode2)) {
19852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19853 }
19854 arg2 = static_cast< long >(val2);
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 resultobj = result;
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19869 PyObject *resultobj = 0;
19870 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19871 bool arg2 = (bool) false ;
19872 size_t result;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 bool val2 ;
19876 int ecode2 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 PyObject * obj1 = 0 ;
19879 char * kwnames[] = {
19880 (char *) "self",(char *) "recursive", NULL
19881 };
19882
19883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19885 if (!SWIG_IsOK(res1)) {
19886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19887 }
19888 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19889 if (obj1) {
19890 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19891 if (!SWIG_IsOK(ecode2)) {
19892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19893 }
19894 arg2 = static_cast< bool >(val2);
19895 }
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19899 wxPyEndAllowThreads(__tstate);
19900 if (PyErr_Occurred()) SWIG_fail;
19901 }
19902 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj = 0;
19911 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19912 bool arg2 = (bool) false ;
19913 size_t result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 bool val2 ;
19917 int ecode2 = 0 ;
19918 PyObject * obj0 = 0 ;
19919 PyObject * obj1 = 0 ;
19920 char * kwnames[] = {
19921 (char *) "self",(char *) "recursive", NULL
19922 };
19923
19924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19926 if (!SWIG_IsOK(res1)) {
19927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19928 }
19929 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19930 if (obj1) {
19931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19932 if (!SWIG_IsOK(ecode2)) {
19933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19934 }
19935 arg2 = static_cast< bool >(val2);
19936 }
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19944 return resultobj;
19945 fail:
19946 return NULL;
19947 }
19948
19949
19950 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19951 PyObject *resultobj = 0;
19952 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19953 wxString *arg2 = 0 ;
19954 bool result;
19955 void *argp1 = 0 ;
19956 int res1 = 0 ;
19957 bool temp2 = false ;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char * kwnames[] = {
19961 (char *) "self",(char *) "name", NULL
19962 };
19963
19964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19966 if (!SWIG_IsOK(res1)) {
19967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19968 }
19969 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19970 {
19971 arg2 = wxString_in_helper(obj1);
19972 if (arg2 == NULL) SWIG_fail;
19973 temp2 = true;
19974 }
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 {
19982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19983 }
19984 {
19985 if (temp2)
19986 delete arg2;
19987 }
19988 return resultobj;
19989 fail:
19990 {
19991 if (temp2)
19992 delete arg2;
19993 }
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = 0;
20000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20001 wxString *arg2 = 0 ;
20002 bool result;
20003 void *argp1 = 0 ;
20004 int res1 = 0 ;
20005 bool temp2 = false ;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 char * kwnames[] = {
20009 (char *) "self",(char *) "name", NULL
20010 };
20011
20012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20014 if (!SWIG_IsOK(res1)) {
20015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20016 }
20017 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20018 {
20019 arg2 = wxString_in_helper(obj1);
20020 if (arg2 == NULL) SWIG_fail;
20021 temp2 = true;
20022 }
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 {
20030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20031 }
20032 {
20033 if (temp2)
20034 delete arg2;
20035 }
20036 return resultobj;
20037 fail:
20038 {
20039 if (temp2)
20040 delete arg2;
20041 }
20042 return NULL;
20043 }
20044
20045
20046 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20047 PyObject *resultobj = 0;
20048 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20049 wxString *arg2 = 0 ;
20050 bool result;
20051 void *argp1 = 0 ;
20052 int res1 = 0 ;
20053 bool temp2 = false ;
20054 PyObject * obj0 = 0 ;
20055 PyObject * obj1 = 0 ;
20056 char * kwnames[] = {
20057 (char *) "self",(char *) "name", NULL
20058 };
20059
20060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20062 if (!SWIG_IsOK(res1)) {
20063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20064 }
20065 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20066 {
20067 arg2 = wxString_in_helper(obj1);
20068 if (arg2 == NULL) SWIG_fail;
20069 temp2 = true;
20070 }
20071 {
20072 PyThreadState* __tstate = wxPyBeginAllowThreads();
20073 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20074 wxPyEndAllowThreads(__tstate);
20075 if (PyErr_Occurred()) SWIG_fail;
20076 }
20077 {
20078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20079 }
20080 {
20081 if (temp2)
20082 delete arg2;
20083 }
20084 return resultobj;
20085 fail:
20086 {
20087 if (temp2)
20088 delete arg2;
20089 }
20090 return NULL;
20091 }
20092
20093
20094 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj = 0;
20096 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20097 wxString *arg2 = 0 ;
20098 wxConfigBase::EntryType result;
20099 void *argp1 = 0 ;
20100 int res1 = 0 ;
20101 bool temp2 = false ;
20102 PyObject * obj0 = 0 ;
20103 PyObject * obj1 = 0 ;
20104 char * kwnames[] = {
20105 (char *) "self",(char *) "name", NULL
20106 };
20107
20108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20110 if (!SWIG_IsOK(res1)) {
20111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20112 }
20113 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20114 {
20115 arg2 = wxString_in_helper(obj1);
20116 if (arg2 == NULL) SWIG_fail;
20117 temp2 = true;
20118 }
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20122 wxPyEndAllowThreads(__tstate);
20123 if (PyErr_Occurred()) SWIG_fail;
20124 }
20125 resultobj = SWIG_From_int(static_cast< int >(result));
20126 {
20127 if (temp2)
20128 delete arg2;
20129 }
20130 return resultobj;
20131 fail:
20132 {
20133 if (temp2)
20134 delete arg2;
20135 }
20136 return NULL;
20137 }
20138
20139
20140 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20141 PyObject *resultobj = 0;
20142 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20143 wxString *arg2 = 0 ;
20144 wxString const &arg3_defvalue = wxPyEmptyString ;
20145 wxString *arg3 = (wxString *) &arg3_defvalue ;
20146 wxString result;
20147 void *argp1 = 0 ;
20148 int res1 = 0 ;
20149 bool temp2 = false ;
20150 bool temp3 = false ;
20151 PyObject * obj0 = 0 ;
20152 PyObject * obj1 = 0 ;
20153 PyObject * obj2 = 0 ;
20154 char * kwnames[] = {
20155 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20156 };
20157
20158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20162 }
20163 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20164 {
20165 arg2 = wxString_in_helper(obj1);
20166 if (arg2 == NULL) SWIG_fail;
20167 temp2 = true;
20168 }
20169 if (obj2) {
20170 {
20171 arg3 = wxString_in_helper(obj2);
20172 if (arg3 == NULL) SWIG_fail;
20173 temp3 = true;
20174 }
20175 }
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 {
20183 #if wxUSE_UNICODE
20184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20185 #else
20186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20187 #endif
20188 }
20189 {
20190 if (temp2)
20191 delete arg2;
20192 }
20193 {
20194 if (temp3)
20195 delete arg3;
20196 }
20197 return resultobj;
20198 fail:
20199 {
20200 if (temp2)
20201 delete arg2;
20202 }
20203 {
20204 if (temp3)
20205 delete arg3;
20206 }
20207 return NULL;
20208 }
20209
20210
20211 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj = 0;
20213 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20214 wxString *arg2 = 0 ;
20215 long arg3 = (long) 0 ;
20216 long result;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 bool temp2 = false ;
20220 long val3 ;
20221 int ecode3 = 0 ;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 PyObject * obj2 = 0 ;
20225 char * kwnames[] = {
20226 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20227 };
20228
20229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20231 if (!SWIG_IsOK(res1)) {
20232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20233 }
20234 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20235 {
20236 arg2 = wxString_in_helper(obj1);
20237 if (arg2 == NULL) SWIG_fail;
20238 temp2 = true;
20239 }
20240 if (obj2) {
20241 ecode3 = SWIG_AsVal_long(obj2, &val3);
20242 if (!SWIG_IsOK(ecode3)) {
20243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20244 }
20245 arg3 = static_cast< long >(val3);
20246 }
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_From_long(static_cast< long >(result));
20254 {
20255 if (temp2)
20256 delete arg2;
20257 }
20258 return resultobj;
20259 fail:
20260 {
20261 if (temp2)
20262 delete arg2;
20263 }
20264 return NULL;
20265 }
20266
20267
20268 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj = 0;
20270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20271 wxString *arg2 = 0 ;
20272 double arg3 = (double) 0.0 ;
20273 double result;
20274 void *argp1 = 0 ;
20275 int res1 = 0 ;
20276 bool temp2 = false ;
20277 double val3 ;
20278 int ecode3 = 0 ;
20279 PyObject * obj0 = 0 ;
20280 PyObject * obj1 = 0 ;
20281 PyObject * obj2 = 0 ;
20282 char * kwnames[] = {
20283 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20284 };
20285
20286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20288 if (!SWIG_IsOK(res1)) {
20289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20290 }
20291 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20292 {
20293 arg2 = wxString_in_helper(obj1);
20294 if (arg2 == NULL) SWIG_fail;
20295 temp2 = true;
20296 }
20297 if (obj2) {
20298 ecode3 = SWIG_AsVal_double(obj2, &val3);
20299 if (!SWIG_IsOK(ecode3)) {
20300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20301 }
20302 arg3 = static_cast< double >(val3);
20303 }
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_From_double(static_cast< double >(result));
20311 {
20312 if (temp2)
20313 delete arg2;
20314 }
20315 return resultobj;
20316 fail:
20317 {
20318 if (temp2)
20319 delete arg2;
20320 }
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20326 PyObject *resultobj = 0;
20327 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20328 wxString *arg2 = 0 ;
20329 bool arg3 = (bool) false ;
20330 bool result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 bool temp2 = false ;
20334 bool val3 ;
20335 int ecode3 = 0 ;
20336 PyObject * obj0 = 0 ;
20337 PyObject * obj1 = 0 ;
20338 PyObject * obj2 = 0 ;
20339 char * kwnames[] = {
20340 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20341 };
20342
20343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20345 if (!SWIG_IsOK(res1)) {
20346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20347 }
20348 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20349 {
20350 arg2 = wxString_in_helper(obj1);
20351 if (arg2 == NULL) SWIG_fail;
20352 temp2 = true;
20353 }
20354 if (obj2) {
20355 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20356 if (!SWIG_IsOK(ecode3)) {
20357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20358 }
20359 arg3 = static_cast< bool >(val3);
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 {
20368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20369 }
20370 {
20371 if (temp2)
20372 delete arg2;
20373 }
20374 return resultobj;
20375 fail:
20376 {
20377 if (temp2)
20378 delete arg2;
20379 }
20380 return NULL;
20381 }
20382
20383
20384 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj = 0;
20386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20387 wxString *arg2 = 0 ;
20388 wxString *arg3 = 0 ;
20389 bool result;
20390 void *argp1 = 0 ;
20391 int res1 = 0 ;
20392 bool temp2 = false ;
20393 bool temp3 = false ;
20394 PyObject * obj0 = 0 ;
20395 PyObject * obj1 = 0 ;
20396 PyObject * obj2 = 0 ;
20397 char * kwnames[] = {
20398 (char *) "self",(char *) "key",(char *) "value", NULL
20399 };
20400
20401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20405 }
20406 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20407 {
20408 arg2 = wxString_in_helper(obj1);
20409 if (arg2 == NULL) SWIG_fail;
20410 temp2 = true;
20411 }
20412 {
20413 arg3 = wxString_in_helper(obj2);
20414 if (arg3 == NULL) SWIG_fail;
20415 temp3 = true;
20416 }
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20425 }
20426 {
20427 if (temp2)
20428 delete arg2;
20429 }
20430 {
20431 if (temp3)
20432 delete arg3;
20433 }
20434 return resultobj;
20435 fail:
20436 {
20437 if (temp2)
20438 delete arg2;
20439 }
20440 {
20441 if (temp3)
20442 delete arg3;
20443 }
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj = 0;
20450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20451 wxString *arg2 = 0 ;
20452 long arg3 ;
20453 bool result;
20454 void *argp1 = 0 ;
20455 int res1 = 0 ;
20456 bool temp2 = false ;
20457 long val3 ;
20458 int ecode3 = 0 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "self",(char *) "key",(char *) "value", NULL
20464 };
20465
20466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20470 }
20471 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20472 {
20473 arg2 = wxString_in_helper(obj1);
20474 if (arg2 == NULL) SWIG_fail;
20475 temp2 = true;
20476 }
20477 ecode3 = SWIG_AsVal_long(obj2, &val3);
20478 if (!SWIG_IsOK(ecode3)) {
20479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20480 }
20481 arg3 = static_cast< long >(val3);
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 {
20489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20490 }
20491 {
20492 if (temp2)
20493 delete arg2;
20494 }
20495 return resultobj;
20496 fail:
20497 {
20498 if (temp2)
20499 delete arg2;
20500 }
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj = 0;
20507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20508 wxString *arg2 = 0 ;
20509 double arg3 ;
20510 bool result;
20511 void *argp1 = 0 ;
20512 int res1 = 0 ;
20513 bool temp2 = false ;
20514 double val3 ;
20515 int ecode3 = 0 ;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 PyObject * obj2 = 0 ;
20519 char * kwnames[] = {
20520 (char *) "self",(char *) "key",(char *) "value", NULL
20521 };
20522
20523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20525 if (!SWIG_IsOK(res1)) {
20526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20527 }
20528 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20529 {
20530 arg2 = wxString_in_helper(obj1);
20531 if (arg2 == NULL) SWIG_fail;
20532 temp2 = true;
20533 }
20534 ecode3 = SWIG_AsVal_double(obj2, &val3);
20535 if (!SWIG_IsOK(ecode3)) {
20536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20537 }
20538 arg3 = static_cast< double >(val3);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20547 }
20548 {
20549 if (temp2)
20550 delete arg2;
20551 }
20552 return resultobj;
20553 fail:
20554 {
20555 if (temp2)
20556 delete arg2;
20557 }
20558 return NULL;
20559 }
20560
20561
20562 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj = 0;
20564 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20565 wxString *arg2 = 0 ;
20566 bool arg3 ;
20567 bool result;
20568 void *argp1 = 0 ;
20569 int res1 = 0 ;
20570 bool temp2 = false ;
20571 bool val3 ;
20572 int ecode3 = 0 ;
20573 PyObject * obj0 = 0 ;
20574 PyObject * obj1 = 0 ;
20575 PyObject * obj2 = 0 ;
20576 char * kwnames[] = {
20577 (char *) "self",(char *) "key",(char *) "value", NULL
20578 };
20579
20580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20584 }
20585 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20586 {
20587 arg2 = wxString_in_helper(obj1);
20588 if (arg2 == NULL) SWIG_fail;
20589 temp2 = true;
20590 }
20591 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20592 if (!SWIG_IsOK(ecode3)) {
20593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20594 }
20595 arg3 = static_cast< bool >(val3);
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 {
20606 if (temp2)
20607 delete arg2;
20608 }
20609 return resultobj;
20610 fail:
20611 {
20612 if (temp2)
20613 delete arg2;
20614 }
20615 return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj = 0;
20621 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20622 bool arg2 = (bool) false ;
20623 bool result;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 bool val2 ;
20627 int ecode2 = 0 ;
20628 PyObject * obj0 = 0 ;
20629 PyObject * obj1 = 0 ;
20630 char * kwnames[] = {
20631 (char *) "self",(char *) "currentOnly", NULL
20632 };
20633
20634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20638 }
20639 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20640 if (obj1) {
20641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20642 if (!SWIG_IsOK(ecode2)) {
20643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20644 }
20645 arg2 = static_cast< bool >(val2);
20646 }
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (bool)(arg1)->Flush(arg2);
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 {
20654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20655 }
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20663 PyObject *resultobj = 0;
20664 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20665 wxString *arg2 = 0 ;
20666 wxString *arg3 = 0 ;
20667 bool result;
20668 void *argp1 = 0 ;
20669 int res1 = 0 ;
20670 bool temp2 = false ;
20671 bool temp3 = false ;
20672 PyObject * obj0 = 0 ;
20673 PyObject * obj1 = 0 ;
20674 PyObject * obj2 = 0 ;
20675 char * kwnames[] = {
20676 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20677 };
20678
20679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20681 if (!SWIG_IsOK(res1)) {
20682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20683 }
20684 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20685 {
20686 arg2 = wxString_in_helper(obj1);
20687 if (arg2 == NULL) SWIG_fail;
20688 temp2 = true;
20689 }
20690 {
20691 arg3 = wxString_in_helper(obj2);
20692 if (arg3 == NULL) SWIG_fail;
20693 temp3 = true;
20694 }
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 {
20702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20703 }
20704 {
20705 if (temp2)
20706 delete arg2;
20707 }
20708 {
20709 if (temp3)
20710 delete arg3;
20711 }
20712 return resultobj;
20713 fail:
20714 {
20715 if (temp2)
20716 delete arg2;
20717 }
20718 {
20719 if (temp3)
20720 delete arg3;
20721 }
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj = 0;
20728 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20729 wxString *arg2 = 0 ;
20730 wxString *arg3 = 0 ;
20731 bool result;
20732 void *argp1 = 0 ;
20733 int res1 = 0 ;
20734 bool temp2 = false ;
20735 bool temp3 = false ;
20736 PyObject * obj0 = 0 ;
20737 PyObject * obj1 = 0 ;
20738 PyObject * obj2 = 0 ;
20739 char * kwnames[] = {
20740 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20741 };
20742
20743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20745 if (!SWIG_IsOK(res1)) {
20746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20747 }
20748 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20749 {
20750 arg2 = wxString_in_helper(obj1);
20751 if (arg2 == NULL) SWIG_fail;
20752 temp2 = true;
20753 }
20754 {
20755 arg3 = wxString_in_helper(obj2);
20756 if (arg3 == NULL) SWIG_fail;
20757 temp3 = true;
20758 }
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 {
20766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20767 }
20768 {
20769 if (temp2)
20770 delete arg2;
20771 }
20772 {
20773 if (temp3)
20774 delete arg3;
20775 }
20776 return resultobj;
20777 fail:
20778 {
20779 if (temp2)
20780 delete arg2;
20781 }
20782 {
20783 if (temp3)
20784 delete arg3;
20785 }
20786 return NULL;
20787 }
20788
20789
20790 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj = 0;
20792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20793 wxString *arg2 = 0 ;
20794 bool arg3 = (bool) true ;
20795 bool result;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 bool temp2 = false ;
20799 bool val3 ;
20800 int ecode3 = 0 ;
20801 PyObject * obj0 = 0 ;
20802 PyObject * obj1 = 0 ;
20803 PyObject * obj2 = 0 ;
20804 char * kwnames[] = {
20805 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20806 };
20807
20808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20810 if (!SWIG_IsOK(res1)) {
20811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20812 }
20813 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20814 {
20815 arg2 = wxString_in_helper(obj1);
20816 if (arg2 == NULL) SWIG_fail;
20817 temp2 = true;
20818 }
20819 if (obj2) {
20820 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20821 if (!SWIG_IsOK(ecode3)) {
20822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20823 }
20824 arg3 = static_cast< bool >(val3);
20825 }
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20834 }
20835 {
20836 if (temp2)
20837 delete arg2;
20838 }
20839 return resultobj;
20840 fail:
20841 {
20842 if (temp2)
20843 delete arg2;
20844 }
20845 return NULL;
20846 }
20847
20848
20849 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20850 PyObject *resultobj = 0;
20851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20852 wxString *arg2 = 0 ;
20853 bool result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 bool temp2 = false ;
20857 PyObject * obj0 = 0 ;
20858 PyObject * obj1 = 0 ;
20859 char * kwnames[] = {
20860 (char *) "self",(char *) "key", NULL
20861 };
20862
20863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20867 }
20868 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20869 {
20870 arg2 = wxString_in_helper(obj1);
20871 if (arg2 == NULL) SWIG_fail;
20872 temp2 = true;
20873 }
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 {
20884 if (temp2)
20885 delete arg2;
20886 }
20887 return resultobj;
20888 fail:
20889 {
20890 if (temp2)
20891 delete arg2;
20892 }
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20898 PyObject *resultobj = 0;
20899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20900 bool result;
20901 void *argp1 = 0 ;
20902 int res1 = 0 ;
20903 PyObject *swig_obj[1] ;
20904
20905 if (!args) SWIG_fail;
20906 swig_obj[0] = args;
20907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20908 if (!SWIG_IsOK(res1)) {
20909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20910 }
20911 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20912 {
20913 PyThreadState* __tstate = wxPyBeginAllowThreads();
20914 result = (bool)(arg1)->DeleteAll();
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 {
20919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20920 }
20921 return resultobj;
20922 fail:
20923 return NULL;
20924 }
20925
20926
20927 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20928 PyObject *resultobj = 0;
20929 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20930 bool arg2 = (bool) true ;
20931 void *argp1 = 0 ;
20932 int res1 = 0 ;
20933 bool val2 ;
20934 int ecode2 = 0 ;
20935 PyObject * obj0 = 0 ;
20936 PyObject * obj1 = 0 ;
20937 char * kwnames[] = {
20938 (char *) "self",(char *) "doIt", NULL
20939 };
20940
20941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20943 if (!SWIG_IsOK(res1)) {
20944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20945 }
20946 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20947 if (obj1) {
20948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20949 if (!SWIG_IsOK(ecode2)) {
20950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20951 }
20952 arg2 = static_cast< bool >(val2);
20953 }
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 (arg1)->SetExpandEnvVars(arg2);
20957 wxPyEndAllowThreads(__tstate);
20958 if (PyErr_Occurred()) SWIG_fail;
20959 }
20960 resultobj = SWIG_Py_Void();
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20968 PyObject *resultobj = 0;
20969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20970 bool result;
20971 void *argp1 = 0 ;
20972 int res1 = 0 ;
20973 PyObject *swig_obj[1] ;
20974
20975 if (!args) SWIG_fail;
20976 swig_obj[0] = args;
20977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20978 if (!SWIG_IsOK(res1)) {
20979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20980 }
20981 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 {
20989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20990 }
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj = 0;
20999 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21000 bool arg2 = (bool) true ;
21001 void *argp1 = 0 ;
21002 int res1 = 0 ;
21003 bool val2 ;
21004 int ecode2 = 0 ;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 char * kwnames[] = {
21008 (char *) "self",(char *) "doIt", NULL
21009 };
21010
21011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21015 }
21016 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21017 if (obj1) {
21018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21019 if (!SWIG_IsOK(ecode2)) {
21020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21021 }
21022 arg2 = static_cast< bool >(val2);
21023 }
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 (arg1)->SetRecordDefaults(arg2);
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 resultobj = SWIG_Py_Void();
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21040 bool result;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 PyObject *swig_obj[1] ;
21044
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21050 }
21051 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 {
21059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21060 }
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21068 PyObject *resultobj = 0;
21069 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21070 wxString *arg2 = 0 ;
21071 wxString result;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 bool temp2 = false ;
21075 PyObject * obj0 = 0 ;
21076 PyObject * obj1 = 0 ;
21077 char * kwnames[] = {
21078 (char *) "self",(char *) "str", NULL
21079 };
21080
21081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21083 if (!SWIG_IsOK(res1)) {
21084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21085 }
21086 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21087 {
21088 arg2 = wxString_in_helper(obj1);
21089 if (arg2 == NULL) SWIG_fail;
21090 temp2 = true;
21091 }
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 {
21099 #if wxUSE_UNICODE
21100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21101 #else
21102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21103 #endif
21104 }
21105 {
21106 if (temp2)
21107 delete arg2;
21108 }
21109 return resultobj;
21110 fail:
21111 {
21112 if (temp2)
21113 delete arg2;
21114 }
21115 return NULL;
21116 }
21117
21118
21119 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 PyObject *resultobj = 0;
21121 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21122 wxString result;
21123 void *argp1 = 0 ;
21124 int res1 = 0 ;
21125 PyObject *swig_obj[1] ;
21126
21127 if (!args) SWIG_fail;
21128 swig_obj[0] = args;
21129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21130 if (!SWIG_IsOK(res1)) {
21131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21132 }
21133 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = ((wxConfigBase const *)arg1)->GetAppName();
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 {
21141 #if wxUSE_UNICODE
21142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21143 #else
21144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21145 #endif
21146 }
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21154 PyObject *resultobj = 0;
21155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21156 wxString result;
21157 void *argp1 = 0 ;
21158 int res1 = 0 ;
21159 PyObject *swig_obj[1] ;
21160
21161 if (!args) SWIG_fail;
21162 swig_obj[0] = args;
21163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21164 if (!SWIG_IsOK(res1)) {
21165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21166 }
21167 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21168 {
21169 PyThreadState* __tstate = wxPyBeginAllowThreads();
21170 result = ((wxConfigBase const *)arg1)->GetVendorName();
21171 wxPyEndAllowThreads(__tstate);
21172 if (PyErr_Occurred()) SWIG_fail;
21173 }
21174 {
21175 #if wxUSE_UNICODE
21176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21177 #else
21178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21179 #endif
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj = 0;
21189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21190 wxString *arg2 = 0 ;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 bool temp2 = false ;
21194 PyObject * obj0 = 0 ;
21195 PyObject * obj1 = 0 ;
21196 char * kwnames[] = {
21197 (char *) "self",(char *) "appName", NULL
21198 };
21199
21200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21202 if (!SWIG_IsOK(res1)) {
21203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21204 }
21205 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21206 {
21207 arg2 = wxString_in_helper(obj1);
21208 if (arg2 == NULL) SWIG_fail;
21209 temp2 = true;
21210 }
21211 {
21212 PyThreadState* __tstate = wxPyBeginAllowThreads();
21213 (arg1)->SetAppName((wxString const &)*arg2);
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 resultobj = SWIG_Py_Void();
21218 {
21219 if (temp2)
21220 delete arg2;
21221 }
21222 return resultobj;
21223 fail:
21224 {
21225 if (temp2)
21226 delete arg2;
21227 }
21228 return NULL;
21229 }
21230
21231
21232 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21233 PyObject *resultobj = 0;
21234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21235 wxString *arg2 = 0 ;
21236 void *argp1 = 0 ;
21237 int res1 = 0 ;
21238 bool temp2 = false ;
21239 PyObject * obj0 = 0 ;
21240 PyObject * obj1 = 0 ;
21241 char * kwnames[] = {
21242 (char *) "self",(char *) "vendorName", NULL
21243 };
21244
21245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21247 if (!SWIG_IsOK(res1)) {
21248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21249 }
21250 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21251 {
21252 arg2 = wxString_in_helper(obj1);
21253 if (arg2 == NULL) SWIG_fail;
21254 temp2 = true;
21255 }
21256 {
21257 PyThreadState* __tstate = wxPyBeginAllowThreads();
21258 (arg1)->SetVendorName((wxString const &)*arg2);
21259 wxPyEndAllowThreads(__tstate);
21260 if (PyErr_Occurred()) SWIG_fail;
21261 }
21262 resultobj = SWIG_Py_Void();
21263 {
21264 if (temp2)
21265 delete arg2;
21266 }
21267 return resultobj;
21268 fail:
21269 {
21270 if (temp2)
21271 delete arg2;
21272 }
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj = 0;
21279 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21280 long arg2 ;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 long val2 ;
21284 int ecode2 = 0 ;
21285 PyObject * obj0 = 0 ;
21286 PyObject * obj1 = 0 ;
21287 char * kwnames[] = {
21288 (char *) "self",(char *) "style", NULL
21289 };
21290
21291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21295 }
21296 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21297 ecode2 = SWIG_AsVal_long(obj1, &val2);
21298 if (!SWIG_IsOK(ecode2)) {
21299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21300 }
21301 arg2 = static_cast< long >(val2);
21302 {
21303 PyThreadState* __tstate = wxPyBeginAllowThreads();
21304 (arg1)->SetStyle(arg2);
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 resultobj = SWIG_Py_Void();
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21316 PyObject *resultobj = 0;
21317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21318 long result;
21319 void *argp1 = 0 ;
21320 int res1 = 0 ;
21321 PyObject *swig_obj[1] ;
21322
21323 if (!args) SWIG_fail;
21324 swig_obj[0] = args;
21325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21326 if (!SWIG_IsOK(res1)) {
21327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21328 }
21329 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21333 wxPyEndAllowThreads(__tstate);
21334 if (PyErr_Occurred()) SWIG_fail;
21335 }
21336 resultobj = SWIG_From_long(static_cast< long >(result));
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *obj;
21345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21346 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21347 return SWIG_Py_Void();
21348 }
21349
21350 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21351 PyObject *resultobj = 0;
21352 wxString const &arg1_defvalue = wxPyEmptyString ;
21353 wxString *arg1 = (wxString *) &arg1_defvalue ;
21354 wxString const &arg2_defvalue = wxPyEmptyString ;
21355 wxString *arg2 = (wxString *) &arg2_defvalue ;
21356 wxString const &arg3_defvalue = wxPyEmptyString ;
21357 wxString *arg3 = (wxString *) &arg3_defvalue ;
21358 wxString const &arg4_defvalue = wxPyEmptyString ;
21359 wxString *arg4 = (wxString *) &arg4_defvalue ;
21360 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21361 wxConfig *result = 0 ;
21362 bool temp1 = false ;
21363 bool temp2 = false ;
21364 bool temp3 = false ;
21365 bool temp4 = false ;
21366 long val5 ;
21367 int ecode5 = 0 ;
21368 PyObject * obj0 = 0 ;
21369 PyObject * obj1 = 0 ;
21370 PyObject * obj2 = 0 ;
21371 PyObject * obj3 = 0 ;
21372 PyObject * obj4 = 0 ;
21373 char * kwnames[] = {
21374 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21375 };
21376
21377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21378 if (obj0) {
21379 {
21380 arg1 = wxString_in_helper(obj0);
21381 if (arg1 == NULL) SWIG_fail;
21382 temp1 = true;
21383 }
21384 }
21385 if (obj1) {
21386 {
21387 arg2 = wxString_in_helper(obj1);
21388 if (arg2 == NULL) SWIG_fail;
21389 temp2 = true;
21390 }
21391 }
21392 if (obj2) {
21393 {
21394 arg3 = wxString_in_helper(obj2);
21395 if (arg3 == NULL) SWIG_fail;
21396 temp3 = true;
21397 }
21398 }
21399 if (obj3) {
21400 {
21401 arg4 = wxString_in_helper(obj3);
21402 if (arg4 == NULL) SWIG_fail;
21403 temp4 = true;
21404 }
21405 }
21406 if (obj4) {
21407 ecode5 = SWIG_AsVal_long(obj4, &val5);
21408 if (!SWIG_IsOK(ecode5)) {
21409 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21410 }
21411 arg5 = static_cast< long >(val5);
21412 }
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21420 {
21421 if (temp1)
21422 delete arg1;
21423 }
21424 {
21425 if (temp2)
21426 delete arg2;
21427 }
21428 {
21429 if (temp3)
21430 delete arg3;
21431 }
21432 {
21433 if (temp4)
21434 delete arg4;
21435 }
21436 return resultobj;
21437 fail:
21438 {
21439 if (temp1)
21440 delete arg1;
21441 }
21442 {
21443 if (temp2)
21444 delete arg2;
21445 }
21446 {
21447 if (temp3)
21448 delete arg3;
21449 }
21450 {
21451 if (temp4)
21452 delete arg4;
21453 }
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *resultobj = 0;
21460 wxConfig *arg1 = (wxConfig *) 0 ;
21461 void *argp1 = 0 ;
21462 int res1 = 0 ;
21463 PyObject *swig_obj[1] ;
21464
21465 if (!args) SWIG_fail;
21466 swig_obj[0] = args;
21467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21468 if (!SWIG_IsOK(res1)) {
21469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21470 }
21471 arg1 = reinterpret_cast< wxConfig * >(argp1);
21472 {
21473 PyThreadState* __tstate = wxPyBeginAllowThreads();
21474 delete arg1;
21475
21476 wxPyEndAllowThreads(__tstate);
21477 if (PyErr_Occurred()) SWIG_fail;
21478 }
21479 resultobj = SWIG_Py_Void();
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *obj;
21488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21489 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21490 return SWIG_Py_Void();
21491 }
21492
21493 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21494 return SWIG_Python_InitShadowInstance(args);
21495 }
21496
21497 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj = 0;
21499 wxString const &arg1_defvalue = wxPyEmptyString ;
21500 wxString *arg1 = (wxString *) &arg1_defvalue ;
21501 wxString const &arg2_defvalue = wxPyEmptyString ;
21502 wxString *arg2 = (wxString *) &arg2_defvalue ;
21503 wxString const &arg3_defvalue = wxPyEmptyString ;
21504 wxString *arg3 = (wxString *) &arg3_defvalue ;
21505 wxString const &arg4_defvalue = wxPyEmptyString ;
21506 wxString *arg4 = (wxString *) &arg4_defvalue ;
21507 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21508 wxFileConfig *result = 0 ;
21509 bool temp1 = false ;
21510 bool temp2 = false ;
21511 bool temp3 = false ;
21512 bool temp4 = false ;
21513 long val5 ;
21514 int ecode5 = 0 ;
21515 PyObject * obj0 = 0 ;
21516 PyObject * obj1 = 0 ;
21517 PyObject * obj2 = 0 ;
21518 PyObject * obj3 = 0 ;
21519 PyObject * obj4 = 0 ;
21520 char * kwnames[] = {
21521 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21522 };
21523
21524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21525 if (obj0) {
21526 {
21527 arg1 = wxString_in_helper(obj0);
21528 if (arg1 == NULL) SWIG_fail;
21529 temp1 = true;
21530 }
21531 }
21532 if (obj1) {
21533 {
21534 arg2 = wxString_in_helper(obj1);
21535 if (arg2 == NULL) SWIG_fail;
21536 temp2 = true;
21537 }
21538 }
21539 if (obj2) {
21540 {
21541 arg3 = wxString_in_helper(obj2);
21542 if (arg3 == NULL) SWIG_fail;
21543 temp3 = true;
21544 }
21545 }
21546 if (obj3) {
21547 {
21548 arg4 = wxString_in_helper(obj3);
21549 if (arg4 == NULL) SWIG_fail;
21550 temp4 = true;
21551 }
21552 }
21553 if (obj4) {
21554 ecode5 = SWIG_AsVal_long(obj4, &val5);
21555 if (!SWIG_IsOK(ecode5)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21557 }
21558 arg5 = static_cast< long >(val5);
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21567 {
21568 if (temp1)
21569 delete arg1;
21570 }
21571 {
21572 if (temp2)
21573 delete arg2;
21574 }
21575 {
21576 if (temp3)
21577 delete arg3;
21578 }
21579 {
21580 if (temp4)
21581 delete arg4;
21582 }
21583 return resultobj;
21584 fail:
21585 {
21586 if (temp1)
21587 delete arg1;
21588 }
21589 {
21590 if (temp2)
21591 delete arg2;
21592 }
21593 {
21594 if (temp3)
21595 delete arg3;
21596 }
21597 {
21598 if (temp4)
21599 delete arg4;
21600 }
21601 return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21606 PyObject *resultobj = 0;
21607 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21608 void *argp1 = 0 ;
21609 int res1 = 0 ;
21610 PyObject *swig_obj[1] ;
21611
21612 if (!args) SWIG_fail;
21613 swig_obj[0] = args;
21614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21615 if (!SWIG_IsOK(res1)) {
21616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21617 }
21618 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21619 {
21620 PyThreadState* __tstate = wxPyBeginAllowThreads();
21621 delete arg1;
21622
21623 wxPyEndAllowThreads(__tstate);
21624 if (PyErr_Occurred()) SWIG_fail;
21625 }
21626 resultobj = SWIG_Py_Void();
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 PyObject *obj;
21635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21636 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21637 return SWIG_Py_Void();
21638 }
21639
21640 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 return SWIG_Python_InitShadowInstance(args);
21642 }
21643
21644 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = 0;
21646 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21647 wxString *arg2 = 0 ;
21648 wxConfigPathChanger *result = 0 ;
21649 void *argp1 = 0 ;
21650 int res1 = 0 ;
21651 bool temp2 = false ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 char * kwnames[] = {
21655 (char *) "config",(char *) "entry", NULL
21656 };
21657
21658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21662 }
21663 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21664 {
21665 arg2 = wxString_in_helper(obj1);
21666 if (arg2 == NULL) SWIG_fail;
21667 temp2 = true;
21668 }
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21676 {
21677 if (temp2)
21678 delete arg2;
21679 }
21680 return resultobj;
21681 fail:
21682 {
21683 if (temp2)
21684 delete arg2;
21685 }
21686 return NULL;
21687 }
21688
21689
21690 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21691 PyObject *resultobj = 0;
21692 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 PyObject *swig_obj[1] ;
21696
21697 if (!args) SWIG_fail;
21698 swig_obj[0] = args;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21702 }
21703 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 delete arg1;
21707
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 resultobj = SWIG_Py_Void();
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719 PyObject *resultobj = 0;
21720 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21721 wxString *result = 0 ;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 PyObject *swig_obj[1] ;
21725
21726 if (!args) SWIG_fail;
21727 swig_obj[0] = args;
21728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21731 }
21732 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21733 {
21734 PyThreadState* __tstate = wxPyBeginAllowThreads();
21735 {
21736 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21737 result = (wxString *) &_result_ref;
21738 }
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 #if wxUSE_UNICODE
21744 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21745 #else
21746 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21747 #endif
21748 }
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 PyObject *obj;
21757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21758 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21759 return SWIG_Py_Void();
21760 }
21761
21762 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21763 return SWIG_Python_InitShadowInstance(args);
21764 }
21765
21766 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21767 PyObject *resultobj = 0;
21768 wxString *arg1 = 0 ;
21769 wxString result;
21770 bool temp1 = false ;
21771 PyObject * obj0 = 0 ;
21772 char * kwnames[] = {
21773 (char *) "sz", NULL
21774 };
21775
21776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21777 {
21778 arg1 = wxString_in_helper(obj0);
21779 if (arg1 == NULL) SWIG_fail;
21780 temp1 = true;
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = wxExpandEnvVars((wxString const &)*arg1);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 {
21789 #if wxUSE_UNICODE
21790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21791 #else
21792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21793 #endif
21794 }
21795 {
21796 if (temp1)
21797 delete arg1;
21798 }
21799 return resultobj;
21800 fail:
21801 {
21802 if (temp1)
21803 delete arg1;
21804 }
21805 return NULL;
21806 }
21807
21808
21809 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21810 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21811 return 1;
21812 }
21813
21814
21815 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21816 PyObject *pyobj = 0;
21817
21818 {
21819 #if wxUSE_UNICODE
21820 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21821 #else
21822 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21823 #endif
21824 }
21825 return pyobj;
21826 }
21827
21828
21829 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21830 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21831 return 1;
21832 }
21833
21834
21835 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21836 PyObject *pyobj = 0;
21837
21838 {
21839 #if wxUSE_UNICODE
21840 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21841 #else
21842 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21843 #endif
21844 }
21845 return pyobj;
21846 }
21847
21848
21849 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj = 0;
21851 wxDateTime::Country arg1 ;
21852 int val1 ;
21853 int ecode1 = 0 ;
21854 PyObject * obj0 = 0 ;
21855 char * kwnames[] = {
21856 (char *) "country", NULL
21857 };
21858
21859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21860 ecode1 = SWIG_AsVal_int(obj0, &val1);
21861 if (!SWIG_IsOK(ecode1)) {
21862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21863 }
21864 arg1 = static_cast< wxDateTime::Country >(val1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 wxDateTime::SetCountry(arg1);
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_Py_Void();
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 wxDateTime::Country result;
21881
21882 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (wxDateTime::Country)wxDateTime::GetCountry();
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 resultobj = SWIG_From_int(static_cast< int >(result));
21890 return resultobj;
21891 fail:
21892 return NULL;
21893 }
21894
21895
21896 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21897 PyObject *resultobj = 0;
21898 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21899 bool result;
21900 int val1 ;
21901 int ecode1 = 0 ;
21902 PyObject * obj0 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "country", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21908 if (obj0) {
21909 ecode1 = SWIG_AsVal_int(obj0, &val1);
21910 if (!SWIG_IsOK(ecode1)) {
21911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21912 }
21913 arg1 = static_cast< wxDateTime::Country >(val1);
21914 }
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21918 wxPyEndAllowThreads(__tstate);
21919 if (PyErr_Occurred()) SWIG_fail;
21920 }
21921 {
21922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21923 }
21924 return resultobj;
21925 fail:
21926 return NULL;
21927 }
21928
21929
21930 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21931 PyObject *resultobj = 0;
21932 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21933 int result;
21934 int val1 ;
21935 int ecode1 = 0 ;
21936 PyObject * obj0 = 0 ;
21937 char * kwnames[] = {
21938 (char *) "cal", NULL
21939 };
21940
21941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21942 if (obj0) {
21943 ecode1 = SWIG_AsVal_int(obj0, &val1);
21944 if (!SWIG_IsOK(ecode1)) {
21945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21946 }
21947 arg1 = static_cast< wxDateTime::Calendar >(val1);
21948 }
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = (int)wxDateTime::GetCurrentYear(arg1);
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 resultobj = SWIG_From_int(static_cast< int >(result));
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 int arg1 ;
21965 int result;
21966 int val1 ;
21967 int ecode1 = 0 ;
21968 PyObject * obj0 = 0 ;
21969 char * kwnames[] = {
21970 (char *) "year", NULL
21971 };
21972
21973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21974 ecode1 = SWIG_AsVal_int(obj0, &val1);
21975 if (!SWIG_IsOK(ecode1)) {
21976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21977 }
21978 arg1 = static_cast< int >(val1);
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (int)wxDateTime::ConvertYearToBC(arg1);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 resultobj = SWIG_From_int(static_cast< int >(result));
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21993 PyObject *resultobj = 0;
21994 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21995 wxDateTime::Month result;
21996 int val1 ;
21997 int ecode1 = 0 ;
21998 PyObject * obj0 = 0 ;
21999 char * kwnames[] = {
22000 (char *) "cal", NULL
22001 };
22002
22003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22004 if (obj0) {
22005 ecode1 = SWIG_AsVal_int(obj0, &val1);
22006 if (!SWIG_IsOK(ecode1)) {
22007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22008 }
22009 arg1 = static_cast< wxDateTime::Calendar >(val1);
22010 }
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 resultobj = SWIG_From_int(static_cast< int >(result));
22018 return resultobj;
22019 fail:
22020 return NULL;
22021 }
22022
22023
22024 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22025 PyObject *resultobj = 0;
22026 int arg1 = (int) wxDateTime::Inv_Year ;
22027 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22028 bool result;
22029 int val1 ;
22030 int ecode1 = 0 ;
22031 int val2 ;
22032 int ecode2 = 0 ;
22033 PyObject * obj0 = 0 ;
22034 PyObject * obj1 = 0 ;
22035 char * kwnames[] = {
22036 (char *) "year",(char *) "cal", NULL
22037 };
22038
22039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22040 if (obj0) {
22041 ecode1 = SWIG_AsVal_int(obj0, &val1);
22042 if (!SWIG_IsOK(ecode1)) {
22043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22044 }
22045 arg1 = static_cast< int >(val1);
22046 }
22047 if (obj1) {
22048 ecode2 = SWIG_AsVal_int(obj1, &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22051 }
22052 arg2 = static_cast< wxDateTime::Calendar >(val2);
22053 }
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj = 0;
22071 int arg1 = (int) wxDateTime::Inv_Year ;
22072 int result;
22073 int val1 ;
22074 int ecode1 = 0 ;
22075 PyObject * obj0 = 0 ;
22076 char * kwnames[] = {
22077 (char *) "year", NULL
22078 };
22079
22080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22081 if (obj0) {
22082 ecode1 = SWIG_AsVal_int(obj0, &val1);
22083 if (!SWIG_IsOK(ecode1)) {
22084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22085 }
22086 arg1 = static_cast< int >(val1);
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (int)wxDateTime::GetCentury(arg1);
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 resultobj = SWIG_From_int(static_cast< int >(result));
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj = 0;
22103 int arg1 ;
22104 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22105 int result;
22106 int val1 ;
22107 int ecode1 = 0 ;
22108 int val2 ;
22109 int ecode2 = 0 ;
22110 PyObject * obj0 = 0 ;
22111 PyObject * obj1 = 0 ;
22112 char * kwnames[] = {
22113 (char *) "year",(char *) "cal", NULL
22114 };
22115
22116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22117 ecode1 = SWIG_AsVal_int(obj0, &val1);
22118 if (!SWIG_IsOK(ecode1)) {
22119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22120 }
22121 arg1 = static_cast< int >(val1);
22122 if (obj1) {
22123 ecode2 = SWIG_AsVal_int(obj1, &val2);
22124 if (!SWIG_IsOK(ecode2)) {
22125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22126 }
22127 arg2 = static_cast< wxDateTime::Calendar >(val2);
22128 }
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_From_int(static_cast< int >(result));
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22143 PyObject *resultobj = 0;
22144 wxDateTime::Month arg1 ;
22145 int arg2 = (int) wxDateTime::Inv_Year ;
22146 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22147 int result;
22148 int val1 ;
22149 int ecode1 = 0 ;
22150 int val2 ;
22151 int ecode2 = 0 ;
22152 int val3 ;
22153 int ecode3 = 0 ;
22154 PyObject * obj0 = 0 ;
22155 PyObject * obj1 = 0 ;
22156 PyObject * obj2 = 0 ;
22157 char * kwnames[] = {
22158 (char *) "month",(char *) "year",(char *) "cal", NULL
22159 };
22160
22161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22162 ecode1 = SWIG_AsVal_int(obj0, &val1);
22163 if (!SWIG_IsOK(ecode1)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22165 }
22166 arg1 = static_cast< wxDateTime::Month >(val1);
22167 if (obj1) {
22168 ecode2 = SWIG_AsVal_int(obj1, &val2);
22169 if (!SWIG_IsOK(ecode2)) {
22170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22171 }
22172 arg2 = static_cast< int >(val2);
22173 }
22174 if (obj2) {
22175 ecode3 = SWIG_AsVal_int(obj2, &val3);
22176 if (!SWIG_IsOK(ecode3)) {
22177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22178 }
22179 arg3 = static_cast< wxDateTime::Calendar >(val3);
22180 }
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 resultobj = SWIG_From_int(static_cast< int >(result));
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22195 PyObject *resultobj = 0;
22196 wxDateTime::Month arg1 ;
22197 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22198 wxString result;
22199 int val1 ;
22200 int ecode1 = 0 ;
22201 int val2 ;
22202 int ecode2 = 0 ;
22203 PyObject * obj0 = 0 ;
22204 PyObject * obj1 = 0 ;
22205 char * kwnames[] = {
22206 (char *) "month",(char *) "flags", NULL
22207 };
22208
22209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22210 ecode1 = SWIG_AsVal_int(obj0, &val1);
22211 if (!SWIG_IsOK(ecode1)) {
22212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22213 }
22214 arg1 = static_cast< wxDateTime::Month >(val1);
22215 if (obj1) {
22216 ecode2 = SWIG_AsVal_int(obj1, &val2);
22217 if (!SWIG_IsOK(ecode2)) {
22218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22219 }
22220 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22221 }
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = wxDateTime::GetMonthName(arg1,arg2);
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 {
22229 #if wxUSE_UNICODE
22230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22231 #else
22232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22233 #endif
22234 }
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22242 PyObject *resultobj = 0;
22243 wxDateTime::WeekDay arg1 ;
22244 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22245 wxString result;
22246 int val1 ;
22247 int ecode1 = 0 ;
22248 int val2 ;
22249 int ecode2 = 0 ;
22250 PyObject * obj0 = 0 ;
22251 PyObject * obj1 = 0 ;
22252 char * kwnames[] = {
22253 (char *) "weekday",(char *) "flags", NULL
22254 };
22255
22256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22257 ecode1 = SWIG_AsVal_int(obj0, &val1);
22258 if (!SWIG_IsOK(ecode1)) {
22259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22260 }
22261 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22262 if (obj1) {
22263 ecode2 = SWIG_AsVal_int(obj1, &val2);
22264 if (!SWIG_IsOK(ecode2)) {
22265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22266 }
22267 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22268 }
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = wxDateTime::GetWeekDayName(arg1,arg2);
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 #if wxUSE_UNICODE
22277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22278 #else
22279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22280 #endif
22281 }
22282 return resultobj;
22283 fail:
22284 return NULL;
22285 }
22286
22287
22288 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 PyObject *resultobj = 0;
22290 PyObject *result = 0 ;
22291
22292 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (PyObject *)wxDateTime_GetAmPmStrings();
22296 wxPyEndAllowThreads(__tstate);
22297 if (PyErr_Occurred()) SWIG_fail;
22298 }
22299 resultobj = result;
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22307 PyObject *resultobj = 0;
22308 int arg1 = (int) wxDateTime::Inv_Year ;
22309 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22310 bool result;
22311 int val1 ;
22312 int ecode1 = 0 ;
22313 int val2 ;
22314 int ecode2 = 0 ;
22315 PyObject * obj0 = 0 ;
22316 PyObject * obj1 = 0 ;
22317 char * kwnames[] = {
22318 (char *) "year",(char *) "country", NULL
22319 };
22320
22321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22322 if (obj0) {
22323 ecode1 = SWIG_AsVal_int(obj0, &val1);
22324 if (!SWIG_IsOK(ecode1)) {
22325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22326 }
22327 arg1 = static_cast< int >(val1);
22328 }
22329 if (obj1) {
22330 ecode2 = SWIG_AsVal_int(obj1, &val2);
22331 if (!SWIG_IsOK(ecode2)) {
22332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22333 }
22334 arg2 = static_cast< wxDateTime::Country >(val2);
22335 }
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22339 wxPyEndAllowThreads(__tstate);
22340 if (PyErr_Occurred()) SWIG_fail;
22341 }
22342 {
22343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22344 }
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22352 PyObject *resultobj = 0;
22353 int arg1 = (int) wxDateTime::Inv_Year ;
22354 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22355 wxDateTime result;
22356 int val1 ;
22357 int ecode1 = 0 ;
22358 int val2 ;
22359 int ecode2 = 0 ;
22360 PyObject * obj0 = 0 ;
22361 PyObject * obj1 = 0 ;
22362 char * kwnames[] = {
22363 (char *) "year",(char *) "country", NULL
22364 };
22365
22366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22367 if (obj0) {
22368 ecode1 = SWIG_AsVal_int(obj0, &val1);
22369 if (!SWIG_IsOK(ecode1)) {
22370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22371 }
22372 arg1 = static_cast< int >(val1);
22373 }
22374 if (obj1) {
22375 ecode2 = SWIG_AsVal_int(obj1, &val2);
22376 if (!SWIG_IsOK(ecode2)) {
22377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22378 }
22379 arg2 = static_cast< wxDateTime::Country >(val2);
22380 }
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 result = wxDateTime::GetBeginDST(arg1,arg2);
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22395 PyObject *resultobj = 0;
22396 int arg1 = (int) wxDateTime::Inv_Year ;
22397 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22398 wxDateTime result;
22399 int val1 ;
22400 int ecode1 = 0 ;
22401 int val2 ;
22402 int ecode2 = 0 ;
22403 PyObject * obj0 = 0 ;
22404 PyObject * obj1 = 0 ;
22405 char * kwnames[] = {
22406 (char *) "year",(char *) "country", NULL
22407 };
22408
22409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22410 if (obj0) {
22411 ecode1 = SWIG_AsVal_int(obj0, &val1);
22412 if (!SWIG_IsOK(ecode1)) {
22413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22414 }
22415 arg1 = static_cast< int >(val1);
22416 }
22417 if (obj1) {
22418 ecode2 = SWIG_AsVal_int(obj1, &val2);
22419 if (!SWIG_IsOK(ecode2)) {
22420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22421 }
22422 arg2 = static_cast< wxDateTime::Country >(val2);
22423 }
22424 {
22425 PyThreadState* __tstate = wxPyBeginAllowThreads();
22426 result = wxDateTime::GetEndDST(arg1,arg2);
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22431 return resultobj;
22432 fail:
22433 return NULL;
22434 }
22435
22436
22437 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22438 PyObject *resultobj = 0;
22439 wxDateTime result;
22440
22441 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22442 {
22443 PyThreadState* __tstate = wxPyBeginAllowThreads();
22444 result = wxDateTime::Now();
22445 wxPyEndAllowThreads(__tstate);
22446 if (PyErr_Occurred()) SWIG_fail;
22447 }
22448 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22456 PyObject *resultobj = 0;
22457 wxDateTime result;
22458
22459 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 result = wxDateTime::UNow();
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxDateTime result;
22476
22477 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = wxDateTime::Today();
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22485 return resultobj;
22486 fail:
22487 return NULL;
22488 }
22489
22490
22491 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22492 PyObject *resultobj = 0;
22493 wxDateTime *result = 0 ;
22494
22495 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 result = (wxDateTime *)new wxDateTime();
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj = 0;
22511 time_t arg1 ;
22512 wxDateTime *result = 0 ;
22513 unsigned int val1 ;
22514 int ecode1 = 0 ;
22515 PyObject * obj0 = 0 ;
22516 char * kwnames[] = {
22517 (char *) "timet", NULL
22518 };
22519
22520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22521 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22522 if (!SWIG_IsOK(ecode1)) {
22523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22524 }
22525 arg1 = static_cast< time_t >(val1);
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (wxDateTime *)new wxDateTime(arg1);
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = 0;
22541 double arg1 ;
22542 wxDateTime *result = 0 ;
22543 double val1 ;
22544 int ecode1 = 0 ;
22545 PyObject * obj0 = 0 ;
22546 char * kwnames[] = {
22547 (char *) "jdn", NULL
22548 };
22549
22550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22551 ecode1 = SWIG_AsVal_double(obj0, &val1);
22552 if (!SWIG_IsOK(ecode1)) {
22553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22554 }
22555 arg1 = static_cast< double >(val1);
22556 {
22557 PyThreadState* __tstate = wxPyBeginAllowThreads();
22558 result = (wxDateTime *)new wxDateTime(arg1);
22559 wxPyEndAllowThreads(__tstate);
22560 if (PyErr_Occurred()) SWIG_fail;
22561 }
22562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj = 0;
22571 int arg1 ;
22572 int arg2 = (int) 0 ;
22573 int arg3 = (int) 0 ;
22574 int arg4 = (int) 0 ;
22575 wxDateTime *result = 0 ;
22576 int val1 ;
22577 int ecode1 = 0 ;
22578 int val2 ;
22579 int ecode2 = 0 ;
22580 int val3 ;
22581 int ecode3 = 0 ;
22582 int val4 ;
22583 int ecode4 = 0 ;
22584 PyObject * obj0 = 0 ;
22585 PyObject * obj1 = 0 ;
22586 PyObject * obj2 = 0 ;
22587 PyObject * obj3 = 0 ;
22588 char * kwnames[] = {
22589 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22590 };
22591
22592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22593 ecode1 = SWIG_AsVal_int(obj0, &val1);
22594 if (!SWIG_IsOK(ecode1)) {
22595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22596 }
22597 arg1 = static_cast< int >(val1);
22598 if (obj1) {
22599 ecode2 = SWIG_AsVal_int(obj1, &val2);
22600 if (!SWIG_IsOK(ecode2)) {
22601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22602 }
22603 arg2 = static_cast< int >(val2);
22604 }
22605 if (obj2) {
22606 ecode3 = SWIG_AsVal_int(obj2, &val3);
22607 if (!SWIG_IsOK(ecode3)) {
22608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22609 }
22610 arg3 = static_cast< int >(val3);
22611 }
22612 if (obj3) {
22613 ecode4 = SWIG_AsVal_int(obj3, &val4);
22614 if (!SWIG_IsOK(ecode4)) {
22615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22616 }
22617 arg4 = static_cast< int >(val4);
22618 }
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22633 PyObject *resultobj = 0;
22634 int arg1 ;
22635 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22636 int arg3 = (int) wxDateTime::Inv_Year ;
22637 int arg4 = (int) 0 ;
22638 int arg5 = (int) 0 ;
22639 int arg6 = (int) 0 ;
22640 int arg7 = (int) 0 ;
22641 wxDateTime *result = 0 ;
22642 int val1 ;
22643 int ecode1 = 0 ;
22644 int val2 ;
22645 int ecode2 = 0 ;
22646 int val3 ;
22647 int ecode3 = 0 ;
22648 int val4 ;
22649 int ecode4 = 0 ;
22650 int val5 ;
22651 int ecode5 = 0 ;
22652 int val6 ;
22653 int ecode6 = 0 ;
22654 int val7 ;
22655 int ecode7 = 0 ;
22656 PyObject * obj0 = 0 ;
22657 PyObject * obj1 = 0 ;
22658 PyObject * obj2 = 0 ;
22659 PyObject * obj3 = 0 ;
22660 PyObject * obj4 = 0 ;
22661 PyObject * obj5 = 0 ;
22662 PyObject * obj6 = 0 ;
22663 char * kwnames[] = {
22664 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22665 };
22666
22667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22668 ecode1 = SWIG_AsVal_int(obj0, &val1);
22669 if (!SWIG_IsOK(ecode1)) {
22670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22671 }
22672 arg1 = static_cast< int >(val1);
22673 if (obj1) {
22674 ecode2 = SWIG_AsVal_int(obj1, &val2);
22675 if (!SWIG_IsOK(ecode2)) {
22676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22677 }
22678 arg2 = static_cast< wxDateTime::Month >(val2);
22679 }
22680 if (obj2) {
22681 ecode3 = SWIG_AsVal_int(obj2, &val3);
22682 if (!SWIG_IsOK(ecode3)) {
22683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22684 }
22685 arg3 = static_cast< int >(val3);
22686 }
22687 if (obj3) {
22688 ecode4 = SWIG_AsVal_int(obj3, &val4);
22689 if (!SWIG_IsOK(ecode4)) {
22690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22691 }
22692 arg4 = static_cast< int >(val4);
22693 }
22694 if (obj4) {
22695 ecode5 = SWIG_AsVal_int(obj4, &val5);
22696 if (!SWIG_IsOK(ecode5)) {
22697 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22698 }
22699 arg5 = static_cast< int >(val5);
22700 }
22701 if (obj5) {
22702 ecode6 = SWIG_AsVal_int(obj5, &val6);
22703 if (!SWIG_IsOK(ecode6)) {
22704 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22705 }
22706 arg6 = static_cast< int >(val6);
22707 }
22708 if (obj6) {
22709 ecode7 = SWIG_AsVal_int(obj6, &val7);
22710 if (!SWIG_IsOK(ecode7)) {
22711 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22712 }
22713 arg7 = static_cast< int >(val7);
22714 }
22715 {
22716 PyThreadState* __tstate = wxPyBeginAllowThreads();
22717 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22718 wxPyEndAllowThreads(__tstate);
22719 if (PyErr_Occurred()) SWIG_fail;
22720 }
22721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj = 0;
22730 wxDateTime *arg1 = 0 ;
22731 wxDateTime *result = 0 ;
22732 void *argp1 = 0 ;
22733 int res1 = 0 ;
22734 PyObject * obj0 = 0 ;
22735 char * kwnames[] = {
22736 (char *) "date", NULL
22737 };
22738
22739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22740 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22741 if (!SWIG_IsOK(res1)) {
22742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22743 }
22744 if (!argp1) {
22745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22746 }
22747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22762 PyObject *resultobj = 0;
22763 wxDateTime *arg1 = (wxDateTime *) 0 ;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 PyObject *swig_obj[1] ;
22767
22768 if (!args) SWIG_fail;
22769 swig_obj[0] = args;
22770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22771 if (!SWIG_IsOK(res1)) {
22772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22773 }
22774 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 delete arg1;
22778
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 resultobj = SWIG_Py_Void();
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22790 PyObject *resultobj = 0;
22791 wxDateTime *arg1 = (wxDateTime *) 0 ;
22792 wxDateTime *result = 0 ;
22793 void *argp1 = 0 ;
22794 int res1 = 0 ;
22795 PyObject *swig_obj[1] ;
22796
22797 if (!args) SWIG_fail;
22798 swig_obj[0] = args;
22799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22800 if (!SWIG_IsOK(res1)) {
22801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22802 }
22803 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22804 {
22805 PyThreadState* __tstate = wxPyBeginAllowThreads();
22806 {
22807 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22808 result = (wxDateTime *) &_result_ref;
22809 }
22810 wxPyEndAllowThreads(__tstate);
22811 if (PyErr_Occurred()) SWIG_fail;
22812 }
22813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22814 return resultobj;
22815 fail:
22816 return NULL;
22817 }
22818
22819
22820 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22821 PyObject *resultobj = 0;
22822 wxDateTime *arg1 = (wxDateTime *) 0 ;
22823 time_t arg2 ;
22824 wxDateTime *result = 0 ;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 unsigned int val2 ;
22828 int ecode2 = 0 ;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831 char * kwnames[] = {
22832 (char *) "self",(char *) "timet", NULL
22833 };
22834
22835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22837 if (!SWIG_IsOK(res1)) {
22838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22839 }
22840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22841 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22842 if (!SWIG_IsOK(ecode2)) {
22843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22844 }
22845 arg2 = static_cast< time_t >(val2);
22846 {
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 {
22849 wxDateTime &_result_ref = (arg1)->Set(arg2);
22850 result = (wxDateTime *) &_result_ref;
22851 }
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22863 PyObject *resultobj = 0;
22864 wxDateTime *arg1 = (wxDateTime *) 0 ;
22865 double arg2 ;
22866 wxDateTime *result = 0 ;
22867 void *argp1 = 0 ;
22868 int res1 = 0 ;
22869 double val2 ;
22870 int ecode2 = 0 ;
22871 PyObject * obj0 = 0 ;
22872 PyObject * obj1 = 0 ;
22873 char * kwnames[] = {
22874 (char *) "self",(char *) "jdn", NULL
22875 };
22876
22877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22881 }
22882 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22883 ecode2 = SWIG_AsVal_double(obj1, &val2);
22884 if (!SWIG_IsOK(ecode2)) {
22885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22886 }
22887 arg2 = static_cast< double >(val2);
22888 {
22889 PyThreadState* __tstate = wxPyBeginAllowThreads();
22890 {
22891 wxDateTime &_result_ref = (arg1)->Set(arg2);
22892 result = (wxDateTime *) &_result_ref;
22893 }
22894 wxPyEndAllowThreads(__tstate);
22895 if (PyErr_Occurred()) SWIG_fail;
22896 }
22897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22898 return resultobj;
22899 fail:
22900 return NULL;
22901 }
22902
22903
22904 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22905 PyObject *resultobj = 0;
22906 wxDateTime *arg1 = (wxDateTime *) 0 ;
22907 int arg2 ;
22908 int arg3 = (int) 0 ;
22909 int arg4 = (int) 0 ;
22910 int arg5 = (int) 0 ;
22911 wxDateTime *result = 0 ;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 int val2 ;
22915 int ecode2 = 0 ;
22916 int val3 ;
22917 int ecode3 = 0 ;
22918 int val4 ;
22919 int ecode4 = 0 ;
22920 int val5 ;
22921 int ecode5 = 0 ;
22922 PyObject * obj0 = 0 ;
22923 PyObject * obj1 = 0 ;
22924 PyObject * obj2 = 0 ;
22925 PyObject * obj3 = 0 ;
22926 PyObject * obj4 = 0 ;
22927 char * kwnames[] = {
22928 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22929 };
22930
22931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22933 if (!SWIG_IsOK(res1)) {
22934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22935 }
22936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22937 ecode2 = SWIG_AsVal_int(obj1, &val2);
22938 if (!SWIG_IsOK(ecode2)) {
22939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22940 }
22941 arg2 = static_cast< int >(val2);
22942 if (obj2) {
22943 ecode3 = SWIG_AsVal_int(obj2, &val3);
22944 if (!SWIG_IsOK(ecode3)) {
22945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22946 }
22947 arg3 = static_cast< int >(val3);
22948 }
22949 if (obj3) {
22950 ecode4 = SWIG_AsVal_int(obj3, &val4);
22951 if (!SWIG_IsOK(ecode4)) {
22952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22953 }
22954 arg4 = static_cast< int >(val4);
22955 }
22956 if (obj4) {
22957 ecode5 = SWIG_AsVal_int(obj4, &val5);
22958 if (!SWIG_IsOK(ecode5)) {
22959 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22960 }
22961 arg5 = static_cast< int >(val5);
22962 }
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 {
22966 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22967 result = (wxDateTime *) &_result_ref;
22968 }
22969 wxPyEndAllowThreads(__tstate);
22970 if (PyErr_Occurred()) SWIG_fail;
22971 }
22972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22973 return resultobj;
22974 fail:
22975 return NULL;
22976 }
22977
22978
22979 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj = 0;
22981 wxDateTime *arg1 = (wxDateTime *) 0 ;
22982 int arg2 ;
22983 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22984 int arg4 = (int) wxDateTime::Inv_Year ;
22985 int arg5 = (int) 0 ;
22986 int arg6 = (int) 0 ;
22987 int arg7 = (int) 0 ;
22988 int arg8 = (int) 0 ;
22989 wxDateTime *result = 0 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 int val2 ;
22993 int ecode2 = 0 ;
22994 int val3 ;
22995 int ecode3 = 0 ;
22996 int val4 ;
22997 int ecode4 = 0 ;
22998 int val5 ;
22999 int ecode5 = 0 ;
23000 int val6 ;
23001 int ecode6 = 0 ;
23002 int val7 ;
23003 int ecode7 = 0 ;
23004 int val8 ;
23005 int ecode8 = 0 ;
23006 PyObject * obj0 = 0 ;
23007 PyObject * obj1 = 0 ;
23008 PyObject * obj2 = 0 ;
23009 PyObject * obj3 = 0 ;
23010 PyObject * obj4 = 0 ;
23011 PyObject * obj5 = 0 ;
23012 PyObject * obj6 = 0 ;
23013 PyObject * obj7 = 0 ;
23014 char * kwnames[] = {
23015 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23016 };
23017
23018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23020 if (!SWIG_IsOK(res1)) {
23021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23022 }
23023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23024 ecode2 = SWIG_AsVal_int(obj1, &val2);
23025 if (!SWIG_IsOK(ecode2)) {
23026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23027 }
23028 arg2 = static_cast< int >(val2);
23029 if (obj2) {
23030 ecode3 = SWIG_AsVal_int(obj2, &val3);
23031 if (!SWIG_IsOK(ecode3)) {
23032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23033 }
23034 arg3 = static_cast< wxDateTime::Month >(val3);
23035 }
23036 if (obj3) {
23037 ecode4 = SWIG_AsVal_int(obj3, &val4);
23038 if (!SWIG_IsOK(ecode4)) {
23039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23040 }
23041 arg4 = static_cast< int >(val4);
23042 }
23043 if (obj4) {
23044 ecode5 = SWIG_AsVal_int(obj4, &val5);
23045 if (!SWIG_IsOK(ecode5)) {
23046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23047 }
23048 arg5 = static_cast< int >(val5);
23049 }
23050 if (obj5) {
23051 ecode6 = SWIG_AsVal_int(obj5, &val6);
23052 if (!SWIG_IsOK(ecode6)) {
23053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23054 }
23055 arg6 = static_cast< int >(val6);
23056 }
23057 if (obj6) {
23058 ecode7 = SWIG_AsVal_int(obj6, &val7);
23059 if (!SWIG_IsOK(ecode7)) {
23060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23061 }
23062 arg7 = static_cast< int >(val7);
23063 }
23064 if (obj7) {
23065 ecode8 = SWIG_AsVal_int(obj7, &val8);
23066 if (!SWIG_IsOK(ecode8)) {
23067 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23068 }
23069 arg8 = static_cast< int >(val8);
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 {
23074 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23075 result = (wxDateTime *) &_result_ref;
23076 }
23077 wxPyEndAllowThreads(__tstate);
23078 if (PyErr_Occurred()) SWIG_fail;
23079 }
23080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23081 return resultobj;
23082 fail:
23083 return NULL;
23084 }
23085
23086
23087 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23088 PyObject *resultobj = 0;
23089 wxDateTime *arg1 = (wxDateTime *) 0 ;
23090 wxDateTime *result = 0 ;
23091 void *argp1 = 0 ;
23092 int res1 = 0 ;
23093 PyObject *swig_obj[1] ;
23094
23095 if (!args) SWIG_fail;
23096 swig_obj[0] = args;
23097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23098 if (!SWIG_IsOK(res1)) {
23099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23100 }
23101 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 {
23105 wxDateTime &_result_ref = (arg1)->ResetTime();
23106 result = (wxDateTime *) &_result_ref;
23107 }
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj = 0;
23120 wxDateTime *arg1 = (wxDateTime *) 0 ;
23121 int arg2 ;
23122 wxDateTime *result = 0 ;
23123 void *argp1 = 0 ;
23124 int res1 = 0 ;
23125 int val2 ;
23126 int ecode2 = 0 ;
23127 PyObject * obj0 = 0 ;
23128 PyObject * obj1 = 0 ;
23129 char * kwnames[] = {
23130 (char *) "self",(char *) "year", NULL
23131 };
23132
23133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23135 if (!SWIG_IsOK(res1)) {
23136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23137 }
23138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23139 ecode2 = SWIG_AsVal_int(obj1, &val2);
23140 if (!SWIG_IsOK(ecode2)) {
23141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23142 }
23143 arg2 = static_cast< int >(val2);
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 {
23147 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23148 result = (wxDateTime *) &_result_ref;
23149 }
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj = 0;
23162 wxDateTime *arg1 = (wxDateTime *) 0 ;
23163 wxDateTime::Month arg2 ;
23164 wxDateTime *result = 0 ;
23165 void *argp1 = 0 ;
23166 int res1 = 0 ;
23167 int val2 ;
23168 int ecode2 = 0 ;
23169 PyObject * obj0 = 0 ;
23170 PyObject * obj1 = 0 ;
23171 char * kwnames[] = {
23172 (char *) "self",(char *) "month", NULL
23173 };
23174
23175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23177 if (!SWIG_IsOK(res1)) {
23178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23179 }
23180 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23181 ecode2 = SWIG_AsVal_int(obj1, &val2);
23182 if (!SWIG_IsOK(ecode2)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23184 }
23185 arg2 = static_cast< wxDateTime::Month >(val2);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 {
23189 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23190 result = (wxDateTime *) &_result_ref;
23191 }
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj = 0;
23204 wxDateTime *arg1 = (wxDateTime *) 0 ;
23205 int arg2 ;
23206 wxDateTime *result = 0 ;
23207 void *argp1 = 0 ;
23208 int res1 = 0 ;
23209 int val2 ;
23210 int ecode2 = 0 ;
23211 PyObject * obj0 = 0 ;
23212 PyObject * obj1 = 0 ;
23213 char * kwnames[] = {
23214 (char *) "self",(char *) "day", NULL
23215 };
23216
23217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23219 if (!SWIG_IsOK(res1)) {
23220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23221 }
23222 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23223 ecode2 = SWIG_AsVal_int(obj1, &val2);
23224 if (!SWIG_IsOK(ecode2)) {
23225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23226 }
23227 arg2 = static_cast< int >(val2);
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 {
23231 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23232 result = (wxDateTime *) &_result_ref;
23233 }
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23245 PyObject *resultobj = 0;
23246 wxDateTime *arg1 = (wxDateTime *) 0 ;
23247 int arg2 ;
23248 wxDateTime *result = 0 ;
23249 void *argp1 = 0 ;
23250 int res1 = 0 ;
23251 int val2 ;
23252 int ecode2 = 0 ;
23253 PyObject * obj0 = 0 ;
23254 PyObject * obj1 = 0 ;
23255 char * kwnames[] = {
23256 (char *) "self",(char *) "hour", NULL
23257 };
23258
23259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23261 if (!SWIG_IsOK(res1)) {
23262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23263 }
23264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23265 ecode2 = SWIG_AsVal_int(obj1, &val2);
23266 if (!SWIG_IsOK(ecode2)) {
23267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23268 }
23269 arg2 = static_cast< int >(val2);
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 {
23273 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23274 result = (wxDateTime *) &_result_ref;
23275 }
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj = 0;
23288 wxDateTime *arg1 = (wxDateTime *) 0 ;
23289 int arg2 ;
23290 wxDateTime *result = 0 ;
23291 void *argp1 = 0 ;
23292 int res1 = 0 ;
23293 int val2 ;
23294 int ecode2 = 0 ;
23295 PyObject * obj0 = 0 ;
23296 PyObject * obj1 = 0 ;
23297 char * kwnames[] = {
23298 (char *) "self",(char *) "minute", NULL
23299 };
23300
23301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23303 if (!SWIG_IsOK(res1)) {
23304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23305 }
23306 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23307 ecode2 = SWIG_AsVal_int(obj1, &val2);
23308 if (!SWIG_IsOK(ecode2)) {
23309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23310 }
23311 arg2 = static_cast< int >(val2);
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 {
23315 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23316 result = (wxDateTime *) &_result_ref;
23317 }
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj = 0;
23330 wxDateTime *arg1 = (wxDateTime *) 0 ;
23331 int arg2 ;
23332 wxDateTime *result = 0 ;
23333 void *argp1 = 0 ;
23334 int res1 = 0 ;
23335 int val2 ;
23336 int ecode2 = 0 ;
23337 PyObject * obj0 = 0 ;
23338 PyObject * obj1 = 0 ;
23339 char * kwnames[] = {
23340 (char *) "self",(char *) "second", NULL
23341 };
23342
23343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23345 if (!SWIG_IsOK(res1)) {
23346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23347 }
23348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23349 ecode2 = SWIG_AsVal_int(obj1, &val2);
23350 if (!SWIG_IsOK(ecode2)) {
23351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23352 }
23353 arg2 = static_cast< int >(val2);
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 {
23357 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23358 result = (wxDateTime *) &_result_ref;
23359 }
23360 wxPyEndAllowThreads(__tstate);
23361 if (PyErr_Occurred()) SWIG_fail;
23362 }
23363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj = 0;
23372 wxDateTime *arg1 = (wxDateTime *) 0 ;
23373 int arg2 ;
23374 wxDateTime *result = 0 ;
23375 void *argp1 = 0 ;
23376 int res1 = 0 ;
23377 int val2 ;
23378 int ecode2 = 0 ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "self",(char *) "millisecond", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23387 if (!SWIG_IsOK(res1)) {
23388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23389 }
23390 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23391 ecode2 = SWIG_AsVal_int(obj1, &val2);
23392 if (!SWIG_IsOK(ecode2)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23394 }
23395 arg2 = static_cast< int >(val2);
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 {
23399 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23400 result = (wxDateTime *) &_result_ref;
23401 }
23402 wxPyEndAllowThreads(__tstate);
23403 if (PyErr_Occurred()) SWIG_fail;
23404 }
23405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23406 return resultobj;
23407 fail:
23408 return NULL;
23409 }
23410
23411
23412 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj = 0;
23414 wxDateTime *arg1 = (wxDateTime *) 0 ;
23415 wxDateTime::WeekDay arg2 ;
23416 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23417 wxDateTime *result = 0 ;
23418 void *argp1 = 0 ;
23419 int res1 = 0 ;
23420 int val2 ;
23421 int ecode2 = 0 ;
23422 int val3 ;
23423 int ecode3 = 0 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 PyObject * obj2 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23435 }
23436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23437 ecode2 = SWIG_AsVal_int(obj1, &val2);
23438 if (!SWIG_IsOK(ecode2)) {
23439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23440 }
23441 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23442 if (obj2) {
23443 ecode3 = SWIG_AsVal_int(obj2, &val3);
23444 if (!SWIG_IsOK(ecode3)) {
23445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23446 }
23447 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23448 }
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 {
23452 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23453 result = (wxDateTime *) &_result_ref;
23454 }
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj = 0;
23467 wxDateTime *arg1 = (wxDateTime *) 0 ;
23468 wxDateTime::WeekDay arg2 ;
23469 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23470 wxDateTime result;
23471 void *argp1 = 0 ;
23472 int res1 = 0 ;
23473 int val2 ;
23474 int ecode2 = 0 ;
23475 int val3 ;
23476 int ecode3 = 0 ;
23477 PyObject * obj0 = 0 ;
23478 PyObject * obj1 = 0 ;
23479 PyObject * obj2 = 0 ;
23480 char * kwnames[] = {
23481 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23482 };
23483
23484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23486 if (!SWIG_IsOK(res1)) {
23487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23488 }
23489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23490 ecode2 = SWIG_AsVal_int(obj1, &val2);
23491 if (!SWIG_IsOK(ecode2)) {
23492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23493 }
23494 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23495 if (obj2) {
23496 ecode3 = SWIG_AsVal_int(obj2, &val3);
23497 if (!SWIG_IsOK(ecode3)) {
23498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23499 }
23500 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23501 }
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23516 PyObject *resultobj = 0;
23517 wxDateTime *arg1 = (wxDateTime *) 0 ;
23518 wxDateTime::WeekDay arg2 ;
23519 wxDateTime *result = 0 ;
23520 void *argp1 = 0 ;
23521 int res1 = 0 ;
23522 int val2 ;
23523 int ecode2 = 0 ;
23524 PyObject * obj0 = 0 ;
23525 PyObject * obj1 = 0 ;
23526 char * kwnames[] = {
23527 (char *) "self",(char *) "weekday", NULL
23528 };
23529
23530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23532 if (!SWIG_IsOK(res1)) {
23533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23534 }
23535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23536 ecode2 = SWIG_AsVal_int(obj1, &val2);
23537 if (!SWIG_IsOK(ecode2)) {
23538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23539 }
23540 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 {
23544 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23545 result = (wxDateTime *) &_result_ref;
23546 }
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj = 0;
23559 wxDateTime *arg1 = (wxDateTime *) 0 ;
23560 wxDateTime::WeekDay arg2 ;
23561 wxDateTime result;
23562 void *argp1 = 0 ;
23563 int res1 = 0 ;
23564 int val2 ;
23565 int ecode2 = 0 ;
23566 PyObject * obj0 = 0 ;
23567 PyObject * obj1 = 0 ;
23568 char * kwnames[] = {
23569 (char *) "self",(char *) "weekday", NULL
23570 };
23571
23572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23574 if (!SWIG_IsOK(res1)) {
23575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23576 }
23577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23578 ecode2 = SWIG_AsVal_int(obj1, &val2);
23579 if (!SWIG_IsOK(ecode2)) {
23580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23581 }
23582 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 result = (arg1)->GetNextWeekDay(arg2);
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj = 0;
23598 wxDateTime *arg1 = (wxDateTime *) 0 ;
23599 wxDateTime::WeekDay arg2 ;
23600 wxDateTime *result = 0 ;
23601 void *argp1 = 0 ;
23602 int res1 = 0 ;
23603 int val2 ;
23604 int ecode2 = 0 ;
23605 PyObject * obj0 = 0 ;
23606 PyObject * obj1 = 0 ;
23607 char * kwnames[] = {
23608 (char *) "self",(char *) "weekday", NULL
23609 };
23610
23611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23613 if (!SWIG_IsOK(res1)) {
23614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23615 }
23616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23617 ecode2 = SWIG_AsVal_int(obj1, &val2);
23618 if (!SWIG_IsOK(ecode2)) {
23619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23620 }
23621 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 {
23625 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23626 result = (wxDateTime *) &_result_ref;
23627 }
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj = 0;
23640 wxDateTime *arg1 = (wxDateTime *) 0 ;
23641 wxDateTime::WeekDay arg2 ;
23642 wxDateTime result;
23643 void *argp1 = 0 ;
23644 int res1 = 0 ;
23645 int val2 ;
23646 int ecode2 = 0 ;
23647 PyObject * obj0 = 0 ;
23648 PyObject * obj1 = 0 ;
23649 char * kwnames[] = {
23650 (char *) "self",(char *) "weekday", NULL
23651 };
23652
23653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23657 }
23658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23659 ecode2 = SWIG_AsVal_int(obj1, &val2);
23660 if (!SWIG_IsOK(ecode2)) {
23661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23662 }
23663 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = (arg1)->GetPrevWeekDay(arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxDateTime *arg1 = (wxDateTime *) 0 ;
23680 wxDateTime::WeekDay arg2 ;
23681 int arg3 = (int) 1 ;
23682 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23683 int arg5 = (int) wxDateTime::Inv_Year ;
23684 bool result;
23685 void *argp1 = 0 ;
23686 int res1 = 0 ;
23687 int val2 ;
23688 int ecode2 = 0 ;
23689 int val3 ;
23690 int ecode3 = 0 ;
23691 int val4 ;
23692 int ecode4 = 0 ;
23693 int val5 ;
23694 int ecode5 = 0 ;
23695 PyObject * obj0 = 0 ;
23696 PyObject * obj1 = 0 ;
23697 PyObject * obj2 = 0 ;
23698 PyObject * obj3 = 0 ;
23699 PyObject * obj4 = 0 ;
23700 char * kwnames[] = {
23701 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23702 };
23703
23704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23706 if (!SWIG_IsOK(res1)) {
23707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23708 }
23709 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23710 ecode2 = SWIG_AsVal_int(obj1, &val2);
23711 if (!SWIG_IsOK(ecode2)) {
23712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23713 }
23714 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23715 if (obj2) {
23716 ecode3 = SWIG_AsVal_int(obj2, &val3);
23717 if (!SWIG_IsOK(ecode3)) {
23718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23719 }
23720 arg3 = static_cast< int >(val3);
23721 }
23722 if (obj3) {
23723 ecode4 = SWIG_AsVal_int(obj3, &val4);
23724 if (!SWIG_IsOK(ecode4)) {
23725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23726 }
23727 arg4 = static_cast< wxDateTime::Month >(val4);
23728 }
23729 if (obj4) {
23730 ecode5 = SWIG_AsVal_int(obj4, &val5);
23731 if (!SWIG_IsOK(ecode5)) {
23732 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23733 }
23734 arg5 = static_cast< int >(val5);
23735 }
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23739 wxPyEndAllowThreads(__tstate);
23740 if (PyErr_Occurred()) SWIG_fail;
23741 }
23742 {
23743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23744 }
23745 return resultobj;
23746 fail:
23747 return NULL;
23748 }
23749
23750
23751 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23752 PyObject *resultobj = 0;
23753 wxDateTime *arg1 = (wxDateTime *) 0 ;
23754 wxDateTime::WeekDay arg2 ;
23755 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23756 int arg4 = (int) wxDateTime::Inv_Year ;
23757 bool result;
23758 void *argp1 = 0 ;
23759 int res1 = 0 ;
23760 int val2 ;
23761 int ecode2 = 0 ;
23762 int val3 ;
23763 int ecode3 = 0 ;
23764 int val4 ;
23765 int ecode4 = 0 ;
23766 PyObject * obj0 = 0 ;
23767 PyObject * obj1 = 0 ;
23768 PyObject * obj2 = 0 ;
23769 PyObject * obj3 = 0 ;
23770 char * kwnames[] = {
23771 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23772 };
23773
23774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23776 if (!SWIG_IsOK(res1)) {
23777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23778 }
23779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23780 ecode2 = SWIG_AsVal_int(obj1, &val2);
23781 if (!SWIG_IsOK(ecode2)) {
23782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23783 }
23784 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23785 if (obj2) {
23786 ecode3 = SWIG_AsVal_int(obj2, &val3);
23787 if (!SWIG_IsOK(ecode3)) {
23788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23789 }
23790 arg3 = static_cast< wxDateTime::Month >(val3);
23791 }
23792 if (obj3) {
23793 ecode4 = SWIG_AsVal_int(obj3, &val4);
23794 if (!SWIG_IsOK(ecode4)) {
23795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23796 }
23797 arg4 = static_cast< int >(val4);
23798 }
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23807 }
23808 return resultobj;
23809 fail:
23810 return NULL;
23811 }
23812
23813
23814 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23815 PyObject *resultobj = 0;
23816 wxDateTime *arg1 = (wxDateTime *) 0 ;
23817 wxDateTime::WeekDay arg2 ;
23818 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23819 int arg4 = (int) wxDateTime::Inv_Year ;
23820 wxDateTime result;
23821 void *argp1 = 0 ;
23822 int res1 = 0 ;
23823 int val2 ;
23824 int ecode2 = 0 ;
23825 int val3 ;
23826 int ecode3 = 0 ;
23827 int val4 ;
23828 int ecode4 = 0 ;
23829 PyObject * obj0 = 0 ;
23830 PyObject * obj1 = 0 ;
23831 PyObject * obj2 = 0 ;
23832 PyObject * obj3 = 0 ;
23833 char * kwnames[] = {
23834 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23835 };
23836
23837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23839 if (!SWIG_IsOK(res1)) {
23840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23841 }
23842 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23843 ecode2 = SWIG_AsVal_int(obj1, &val2);
23844 if (!SWIG_IsOK(ecode2)) {
23845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23846 }
23847 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23848 if (obj2) {
23849 ecode3 = SWIG_AsVal_int(obj2, &val3);
23850 if (!SWIG_IsOK(ecode3)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23852 }
23853 arg3 = static_cast< wxDateTime::Month >(val3);
23854 }
23855 if (obj3) {
23856 ecode4 = SWIG_AsVal_int(obj3, &val4);
23857 if (!SWIG_IsOK(ecode4)) {
23858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23859 }
23860 arg4 = static_cast< int >(val4);
23861 }
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23865 wxPyEndAllowThreads(__tstate);
23866 if (PyErr_Occurred()) SWIG_fail;
23867 }
23868 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23876 PyObject *resultobj = 0;
23877 wxDateTime *arg1 = (wxDateTime *) 0 ;
23878 int arg2 ;
23879 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23880 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23881 bool result;
23882 void *argp1 = 0 ;
23883 int res1 = 0 ;
23884 int val2 ;
23885 int ecode2 = 0 ;
23886 int val3 ;
23887 int ecode3 = 0 ;
23888 int val4 ;
23889 int ecode4 = 0 ;
23890 PyObject * obj0 = 0 ;
23891 PyObject * obj1 = 0 ;
23892 PyObject * obj2 = 0 ;
23893 PyObject * obj3 = 0 ;
23894 char * kwnames[] = {
23895 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23896 };
23897
23898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23900 if (!SWIG_IsOK(res1)) {
23901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23902 }
23903 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23904 ecode2 = SWIG_AsVal_int(obj1, &val2);
23905 if (!SWIG_IsOK(ecode2)) {
23906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23907 }
23908 arg2 = static_cast< int >(val2);
23909 if (obj2) {
23910 ecode3 = SWIG_AsVal_int(obj2, &val3);
23911 if (!SWIG_IsOK(ecode3)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23913 }
23914 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23915 }
23916 if (obj3) {
23917 ecode4 = SWIG_AsVal_int(obj3, &val4);
23918 if (!SWIG_IsOK(ecode4)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23920 }
23921 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23922 }
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23931 }
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23939 PyObject *resultobj = 0;
23940 wxDateTime *arg1 = (wxDateTime *) 0 ;
23941 int arg2 ;
23942 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23943 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23944 wxDateTime result;
23945 void *argp1 = 0 ;
23946 int res1 = 0 ;
23947 int val2 ;
23948 int ecode2 = 0 ;
23949 int val3 ;
23950 int ecode3 = 0 ;
23951 int val4 ;
23952 int ecode4 = 0 ;
23953 PyObject * obj0 = 0 ;
23954 PyObject * obj1 = 0 ;
23955 PyObject * obj2 = 0 ;
23956 PyObject * obj3 = 0 ;
23957 char * kwnames[] = {
23958 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23959 };
23960
23961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23963 if (!SWIG_IsOK(res1)) {
23964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23965 }
23966 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23967 ecode2 = SWIG_AsVal_int(obj1, &val2);
23968 if (!SWIG_IsOK(ecode2)) {
23969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23970 }
23971 arg2 = static_cast< int >(val2);
23972 if (obj2) {
23973 ecode3 = SWIG_AsVal_int(obj2, &val3);
23974 if (!SWIG_IsOK(ecode3)) {
23975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23976 }
23977 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23978 }
23979 if (obj3) {
23980 ecode4 = SWIG_AsVal_int(obj3, &val4);
23981 if (!SWIG_IsOK(ecode4)) {
23982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23983 }
23984 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23985 }
23986 {
23987 PyThreadState* __tstate = wxPyBeginAllowThreads();
23988 result = (arg1)->GetWeek(arg2,arg3,arg4);
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj = 0;
24001 int arg1 ;
24002 int arg2 ;
24003 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24004 wxDateTime result;
24005 int val1 ;
24006 int ecode1 = 0 ;
24007 int val2 ;
24008 int ecode2 = 0 ;
24009 int val3 ;
24010 int ecode3 = 0 ;
24011 PyObject * obj0 = 0 ;
24012 PyObject * obj1 = 0 ;
24013 PyObject * obj2 = 0 ;
24014 char * kwnames[] = {
24015 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24016 };
24017
24018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24019 ecode1 = SWIG_AsVal_int(obj0, &val1);
24020 if (!SWIG_IsOK(ecode1)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24022 }
24023 arg1 = static_cast< int >(val1);
24024 ecode2 = SWIG_AsVal_int(obj1, &val2);
24025 if (!SWIG_IsOK(ecode2)) {
24026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24027 }
24028 arg2 = static_cast< int >(val2);
24029 if (obj2) {
24030 ecode3 = SWIG_AsVal_int(obj2, &val3);
24031 if (!SWIG_IsOK(ecode3)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24033 }
24034 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24035 }
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj = 0;
24051 wxDateTime *arg1 = (wxDateTime *) 0 ;
24052 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24053 int arg3 = (int) wxDateTime::Inv_Year ;
24054 wxDateTime *result = 0 ;
24055 void *argp1 = 0 ;
24056 int res1 = 0 ;
24057 int val2 ;
24058 int ecode2 = 0 ;
24059 int val3 ;
24060 int ecode3 = 0 ;
24061 PyObject * obj0 = 0 ;
24062 PyObject * obj1 = 0 ;
24063 PyObject * obj2 = 0 ;
24064 char * kwnames[] = {
24065 (char *) "self",(char *) "month",(char *) "year", NULL
24066 };
24067
24068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24070 if (!SWIG_IsOK(res1)) {
24071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24072 }
24073 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24074 if (obj1) {
24075 ecode2 = SWIG_AsVal_int(obj1, &val2);
24076 if (!SWIG_IsOK(ecode2)) {
24077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24078 }
24079 arg2 = static_cast< wxDateTime::Month >(val2);
24080 }
24081 if (obj2) {
24082 ecode3 = SWIG_AsVal_int(obj2, &val3);
24083 if (!SWIG_IsOK(ecode3)) {
24084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24085 }
24086 arg3 = static_cast< int >(val3);
24087 }
24088 {
24089 PyThreadState* __tstate = wxPyBeginAllowThreads();
24090 {
24091 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24092 result = (wxDateTime *) &_result_ref;
24093 }
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj = 0;
24106 wxDateTime *arg1 = (wxDateTime *) 0 ;
24107 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24108 int arg3 = (int) wxDateTime::Inv_Year ;
24109 wxDateTime result;
24110 void *argp1 = 0 ;
24111 int res1 = 0 ;
24112 int val2 ;
24113 int ecode2 = 0 ;
24114 int val3 ;
24115 int ecode3 = 0 ;
24116 PyObject * obj0 = 0 ;
24117 PyObject * obj1 = 0 ;
24118 PyObject * obj2 = 0 ;
24119 char * kwnames[] = {
24120 (char *) "self",(char *) "month",(char *) "year", NULL
24121 };
24122
24123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24127 }
24128 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24129 if (obj1) {
24130 ecode2 = SWIG_AsVal_int(obj1, &val2);
24131 if (!SWIG_IsOK(ecode2)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24133 }
24134 arg2 = static_cast< wxDateTime::Month >(val2);
24135 }
24136 if (obj2) {
24137 ecode3 = SWIG_AsVal_int(obj2, &val3);
24138 if (!SWIG_IsOK(ecode3)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24140 }
24141 arg3 = static_cast< int >(val3);
24142 }
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (arg1)->GetLastMonthDay(arg2,arg3);
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24157 PyObject *resultobj = 0;
24158 wxDateTime *arg1 = (wxDateTime *) 0 ;
24159 int arg2 ;
24160 wxDateTime *result = 0 ;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 int val2 ;
24164 int ecode2 = 0 ;
24165 PyObject * obj0 = 0 ;
24166 PyObject * obj1 = 0 ;
24167 char * kwnames[] = {
24168 (char *) "self",(char *) "yday", NULL
24169 };
24170
24171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24173 if (!SWIG_IsOK(res1)) {
24174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24175 }
24176 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24177 ecode2 = SWIG_AsVal_int(obj1, &val2);
24178 if (!SWIG_IsOK(ecode2)) {
24179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24180 }
24181 arg2 = static_cast< int >(val2);
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 {
24185 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24186 result = (wxDateTime *) &_result_ref;
24187 }
24188 wxPyEndAllowThreads(__tstate);
24189 if (PyErr_Occurred()) SWIG_fail;
24190 }
24191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj = 0;
24200 wxDateTime *arg1 = (wxDateTime *) 0 ;
24201 int arg2 ;
24202 wxDateTime result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 int val2 ;
24206 int ecode2 = 0 ;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char * kwnames[] = {
24210 (char *) "self",(char *) "yday", NULL
24211 };
24212
24213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24215 if (!SWIG_IsOK(res1)) {
24216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24217 }
24218 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24219 ecode2 = SWIG_AsVal_int(obj1, &val2);
24220 if (!SWIG_IsOK(ecode2)) {
24221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24222 }
24223 arg2 = static_cast< int >(val2);
24224 {
24225 PyThreadState* __tstate = wxPyBeginAllowThreads();
24226 result = (arg1)->GetYearDay(arg2);
24227 wxPyEndAllowThreads(__tstate);
24228 if (PyErr_Occurred()) SWIG_fail;
24229 }
24230 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24231 return resultobj;
24232 fail:
24233 return NULL;
24234 }
24235
24236
24237 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24238 PyObject *resultobj = 0;
24239 wxDateTime *arg1 = (wxDateTime *) 0 ;
24240 double result;
24241 void *argp1 = 0 ;
24242 int res1 = 0 ;
24243 PyObject *swig_obj[1] ;
24244
24245 if (!args) SWIG_fail;
24246 swig_obj[0] = args;
24247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24248 if (!SWIG_IsOK(res1)) {
24249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24250 }
24251 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 result = (double)(arg1)->GetJulianDayNumber();
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 resultobj = SWIG_From_double(static_cast< double >(result));
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *resultobj = 0;
24267 wxDateTime *arg1 = (wxDateTime *) 0 ;
24268 double result;
24269 void *argp1 = 0 ;
24270 int res1 = 0 ;
24271 PyObject *swig_obj[1] ;
24272
24273 if (!args) SWIG_fail;
24274 swig_obj[0] = args;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24278 }
24279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 result = (double)(arg1)->GetJDN();
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 resultobj = SWIG_From_double(static_cast< double >(result));
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24294 PyObject *resultobj = 0;
24295 wxDateTime *arg1 = (wxDateTime *) 0 ;
24296 double result;
24297 void *argp1 = 0 ;
24298 int res1 = 0 ;
24299 PyObject *swig_obj[1] ;
24300
24301 if (!args) SWIG_fail;
24302 swig_obj[0] = args;
24303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24304 if (!SWIG_IsOK(res1)) {
24305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24306 }
24307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 resultobj = SWIG_From_double(static_cast< double >(result));
24315 return resultobj;
24316 fail:
24317 return NULL;
24318 }
24319
24320
24321 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24322 PyObject *resultobj = 0;
24323 wxDateTime *arg1 = (wxDateTime *) 0 ;
24324 double result;
24325 void *argp1 = 0 ;
24326 int res1 = 0 ;
24327 PyObject *swig_obj[1] ;
24328
24329 if (!args) SWIG_fail;
24330 swig_obj[0] = args;
24331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24332 if (!SWIG_IsOK(res1)) {
24333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24334 }
24335 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (double)(arg1)->GetMJD();
24339 wxPyEndAllowThreads(__tstate);
24340 if (PyErr_Occurred()) SWIG_fail;
24341 }
24342 resultobj = SWIG_From_double(static_cast< double >(result));
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 PyObject *resultobj = 0;
24351 wxDateTime *arg1 = (wxDateTime *) 0 ;
24352 double result;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 PyObject *swig_obj[1] ;
24356
24357 if (!args) SWIG_fail;
24358 swig_obj[0] = args;
24359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24360 if (!SWIG_IsOK(res1)) {
24361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24362 }
24363 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (double)(arg1)->GetRataDie();
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 resultobj = SWIG_From_double(static_cast< double >(result));
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj = 0;
24379 wxDateTime *arg1 = (wxDateTime *) 0 ;
24380 wxDateTime::TimeZone *arg2 = 0 ;
24381 bool arg3 = (bool) false ;
24382 wxDateTime result;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 bool temp2 = false ;
24386 bool val3 ;
24387 int ecode3 = 0 ;
24388 PyObject * obj0 = 0 ;
24389 PyObject * obj1 = 0 ;
24390 PyObject * obj2 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24397 if (!SWIG_IsOK(res1)) {
24398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24399 }
24400 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24401 {
24402 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24403 temp2 = true;
24404 }
24405 if (obj2) {
24406 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24407 if (!SWIG_IsOK(ecode3)) {
24408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24409 }
24410 arg3 = static_cast< bool >(val3);
24411 }
24412 {
24413 PyThreadState* __tstate = wxPyBeginAllowThreads();
24414 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24415 wxPyEndAllowThreads(__tstate);
24416 if (PyErr_Occurred()) SWIG_fail;
24417 }
24418 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24419 {
24420 if (temp2) delete arg2;
24421 }
24422 return resultobj;
24423 fail:
24424 {
24425 if (temp2) delete arg2;
24426 }
24427 return NULL;
24428 }
24429
24430
24431 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24432 PyObject *resultobj = 0;
24433 wxDateTime *arg1 = (wxDateTime *) 0 ;
24434 wxDateTime::TimeZone *arg2 = 0 ;
24435 bool arg3 = (bool) false ;
24436 wxDateTime *result = 0 ;
24437 void *argp1 = 0 ;
24438 int res1 = 0 ;
24439 bool temp2 = false ;
24440 bool val3 ;
24441 int ecode3 = 0 ;
24442 PyObject * obj0 = 0 ;
24443 PyObject * obj1 = 0 ;
24444 PyObject * obj2 = 0 ;
24445 char * kwnames[] = {
24446 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24447 };
24448
24449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24453 }
24454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24455 {
24456 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24457 temp2 = true;
24458 }
24459 if (obj2) {
24460 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24461 if (!SWIG_IsOK(ecode3)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24463 }
24464 arg3 = static_cast< bool >(val3);
24465 }
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 {
24469 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24470 result = (wxDateTime *) &_result_ref;
24471 }
24472 wxPyEndAllowThreads(__tstate);
24473 if (PyErr_Occurred()) SWIG_fail;
24474 }
24475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24476 {
24477 if (temp2) delete arg2;
24478 }
24479 return resultobj;
24480 fail:
24481 {
24482 if (temp2) delete arg2;
24483 }
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj = 0;
24490 wxDateTime *arg1 = (wxDateTime *) 0 ;
24491 wxDateTime::TimeZone *arg2 = 0 ;
24492 bool arg3 = (bool) false ;
24493 wxDateTime result;
24494 void *argp1 = 0 ;
24495 int res1 = 0 ;
24496 bool temp2 = false ;
24497 bool val3 ;
24498 int ecode3 = 0 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 PyObject * obj2 = 0 ;
24502 char * kwnames[] = {
24503 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24504 };
24505
24506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24508 if (!SWIG_IsOK(res1)) {
24509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24510 }
24511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24512 {
24513 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24514 temp2 = true;
24515 }
24516 if (obj2) {
24517 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24518 if (!SWIG_IsOK(ecode3)) {
24519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24520 }
24521 arg3 = static_cast< bool >(val3);
24522 }
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24530 {
24531 if (temp2) delete arg2;
24532 }
24533 return resultobj;
24534 fail:
24535 {
24536 if (temp2) delete arg2;
24537 }
24538 return NULL;
24539 }
24540
24541
24542 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24543 PyObject *resultobj = 0;
24544 wxDateTime *arg1 = (wxDateTime *) 0 ;
24545 wxDateTime::TimeZone *arg2 = 0 ;
24546 bool arg3 = (bool) false ;
24547 wxDateTime *result = 0 ;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 bool temp2 = false ;
24551 bool val3 ;
24552 int ecode3 = 0 ;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 PyObject * obj2 = 0 ;
24556 char * kwnames[] = {
24557 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24558 };
24559
24560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24564 }
24565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24566 {
24567 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24568 temp2 = true;
24569 }
24570 if (obj2) {
24571 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24572 if (!SWIG_IsOK(ecode3)) {
24573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24574 }
24575 arg3 = static_cast< bool >(val3);
24576 }
24577 {
24578 PyThreadState* __tstate = wxPyBeginAllowThreads();
24579 {
24580 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24581 result = (wxDateTime *) &_result_ref;
24582 }
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24587 {
24588 if (temp2) delete arg2;
24589 }
24590 return resultobj;
24591 fail:
24592 {
24593 if (temp2) delete arg2;
24594 }
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj = 0;
24601 wxDateTime *arg1 = (wxDateTime *) 0 ;
24602 bool arg2 = (bool) false ;
24603 wxDateTime result;
24604 void *argp1 = 0 ;
24605 int res1 = 0 ;
24606 bool val2 ;
24607 int ecode2 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 PyObject * obj1 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "self",(char *) "noDST", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24616 if (!SWIG_IsOK(res1)) {
24617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24618 }
24619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24620 if (obj1) {
24621 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24622 if (!SWIG_IsOK(ecode2)) {
24623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24624 }
24625 arg2 = static_cast< bool >(val2);
24626 }
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24630 wxPyEndAllowThreads(__tstate);
24631 if (PyErr_Occurred()) SWIG_fail;
24632 }
24633 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 wxDateTime *arg1 = (wxDateTime *) 0 ;
24643 bool arg2 = (bool) false ;
24644 wxDateTime *result = 0 ;
24645 void *argp1 = 0 ;
24646 int res1 = 0 ;
24647 bool val2 ;
24648 int ecode2 = 0 ;
24649 PyObject * obj0 = 0 ;
24650 PyObject * obj1 = 0 ;
24651 char * kwnames[] = {
24652 (char *) "self",(char *) "noDST", NULL
24653 };
24654
24655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24657 if (!SWIG_IsOK(res1)) {
24658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24659 }
24660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24661 if (obj1) {
24662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24663 if (!SWIG_IsOK(ecode2)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24665 }
24666 arg2 = static_cast< bool >(val2);
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 {
24671 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24672 result = (wxDateTime *) &_result_ref;
24673 }
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj = 0;
24686 wxDateTime *arg1 = (wxDateTime *) 0 ;
24687 bool arg2 = (bool) false ;
24688 wxDateTime result;
24689 void *argp1 = 0 ;
24690 int res1 = 0 ;
24691 bool val2 ;
24692 int ecode2 = 0 ;
24693 PyObject * obj0 = 0 ;
24694 PyObject * obj1 = 0 ;
24695 char * kwnames[] = {
24696 (char *) "self",(char *) "noDST", NULL
24697 };
24698
24699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24701 if (!SWIG_IsOK(res1)) {
24702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24703 }
24704 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24705 if (obj1) {
24706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24707 if (!SWIG_IsOK(ecode2)) {
24708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24709 }
24710 arg2 = static_cast< bool >(val2);
24711 }
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24726 PyObject *resultobj = 0;
24727 wxDateTime *arg1 = (wxDateTime *) 0 ;
24728 bool arg2 = (bool) false ;
24729 wxDateTime *result = 0 ;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 bool val2 ;
24733 int ecode2 = 0 ;
24734 PyObject * obj0 = 0 ;
24735 PyObject * obj1 = 0 ;
24736 char * kwnames[] = {
24737 (char *) "self",(char *) "noDST", NULL
24738 };
24739
24740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24742 if (!SWIG_IsOK(res1)) {
24743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24744 }
24745 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24746 if (obj1) {
24747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24748 if (!SWIG_IsOK(ecode2)) {
24749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24750 }
24751 arg2 = static_cast< bool >(val2);
24752 }
24753 {
24754 PyThreadState* __tstate = wxPyBeginAllowThreads();
24755 {
24756 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24757 result = (wxDateTime *) &_result_ref;
24758 }
24759 wxPyEndAllowThreads(__tstate);
24760 if (PyErr_Occurred()) SWIG_fail;
24761 }
24762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24770 PyObject *resultobj = 0;
24771 wxDateTime *arg1 = (wxDateTime *) 0 ;
24772 bool arg2 = (bool) false ;
24773 wxDateTime result;
24774 void *argp1 = 0 ;
24775 int res1 = 0 ;
24776 bool val2 ;
24777 int ecode2 = 0 ;
24778 PyObject * obj0 = 0 ;
24779 PyObject * obj1 = 0 ;
24780 char * kwnames[] = {
24781 (char *) "self",(char *) "noDST", NULL
24782 };
24783
24784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24786 if (!SWIG_IsOK(res1)) {
24787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24788 }
24789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24790 if (obj1) {
24791 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24792 if (!SWIG_IsOK(ecode2)) {
24793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24794 }
24795 arg2 = static_cast< bool >(val2);
24796 }
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj = 0;
24812 wxDateTime *arg1 = (wxDateTime *) 0 ;
24813 bool arg2 = (bool) false ;
24814 wxDateTime *result = 0 ;
24815 void *argp1 = 0 ;
24816 int res1 = 0 ;
24817 bool val2 ;
24818 int ecode2 = 0 ;
24819 PyObject * obj0 = 0 ;
24820 PyObject * obj1 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "self",(char *) "noDST", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24829 }
24830 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24831 if (obj1) {
24832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24833 if (!SWIG_IsOK(ecode2)) {
24834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24835 }
24836 arg2 = static_cast< bool >(val2);
24837 }
24838 {
24839 PyThreadState* __tstate = wxPyBeginAllowThreads();
24840 {
24841 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24842 result = (wxDateTime *) &_result_ref;
24843 }
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj = 0;
24856 wxDateTime *arg1 = (wxDateTime *) 0 ;
24857 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24858 int result;
24859 void *argp1 = 0 ;
24860 int res1 = 0 ;
24861 int val2 ;
24862 int ecode2 = 0 ;
24863 PyObject * obj0 = 0 ;
24864 PyObject * obj1 = 0 ;
24865 char * kwnames[] = {
24866 (char *) "self",(char *) "country", NULL
24867 };
24868
24869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24871 if (!SWIG_IsOK(res1)) {
24872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24873 }
24874 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24875 if (obj1) {
24876 ecode2 = SWIG_AsVal_int(obj1, &val2);
24877 if (!SWIG_IsOK(ecode2)) {
24878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24879 }
24880 arg2 = static_cast< wxDateTime::Country >(val2);
24881 }
24882 {
24883 PyThreadState* __tstate = wxPyBeginAllowThreads();
24884 result = (int)(arg1)->IsDST(arg2);
24885 wxPyEndAllowThreads(__tstate);
24886 if (PyErr_Occurred()) SWIG_fail;
24887 }
24888 resultobj = SWIG_From_int(static_cast< int >(result));
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24896 PyObject *resultobj = 0;
24897 wxDateTime *arg1 = (wxDateTime *) 0 ;
24898 bool result;
24899 void *argp1 = 0 ;
24900 int res1 = 0 ;
24901 PyObject *swig_obj[1] ;
24902
24903 if (!args) SWIG_fail;
24904 swig_obj[0] = args;
24905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24908 }
24909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (bool)((wxDateTime const *)arg1)->IsValid();
24913 wxPyEndAllowThreads(__tstate);
24914 if (PyErr_Occurred()) SWIG_fail;
24915 }
24916 {
24917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24918 }
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 PyObject *resultobj = 0;
24927 wxDateTime *arg1 = (wxDateTime *) 0 ;
24928 time_t result;
24929 void *argp1 = 0 ;
24930 int res1 = 0 ;
24931 PyObject *swig_obj[1] ;
24932
24933 if (!args) SWIG_fail;
24934 swig_obj[0] = args;
24935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24936 if (!SWIG_IsOK(res1)) {
24937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24938 }
24939 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24940 {
24941 PyThreadState* __tstate = wxPyBeginAllowThreads();
24942 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24943 wxPyEndAllowThreads(__tstate);
24944 if (PyErr_Occurred()) SWIG_fail;
24945 }
24946 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24947 return resultobj;
24948 fail:
24949 return NULL;
24950 }
24951
24952
24953 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24954 PyObject *resultobj = 0;
24955 wxDateTime *arg1 = (wxDateTime *) 0 ;
24956 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24957 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24958 int result;
24959 void *argp1 = 0 ;
24960 int res1 = 0 ;
24961 bool temp2 = false ;
24962 PyObject * obj0 = 0 ;
24963 PyObject * obj1 = 0 ;
24964 char * kwnames[] = {
24965 (char *) "self",(char *) "tz", NULL
24966 };
24967
24968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24970 if (!SWIG_IsOK(res1)) {
24971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24972 }
24973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24974 if (obj1) {
24975 {
24976 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24977 temp2 = true;
24978 }
24979 }
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24983 wxPyEndAllowThreads(__tstate);
24984 if (PyErr_Occurred()) SWIG_fail;
24985 }
24986 resultobj = SWIG_From_int(static_cast< int >(result));
24987 {
24988 if (temp2) delete arg2;
24989 }
24990 return resultobj;
24991 fail:
24992 {
24993 if (temp2) delete arg2;
24994 }
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25000 PyObject *resultobj = 0;
25001 wxDateTime *arg1 = (wxDateTime *) 0 ;
25002 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25003 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25004 wxDateTime::Month result;
25005 void *argp1 = 0 ;
25006 int res1 = 0 ;
25007 bool temp2 = false ;
25008 PyObject * obj0 = 0 ;
25009 PyObject * obj1 = 0 ;
25010 char * kwnames[] = {
25011 (char *) "self",(char *) "tz", NULL
25012 };
25013
25014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25016 if (!SWIG_IsOK(res1)) {
25017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25018 }
25019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25020 if (obj1) {
25021 {
25022 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25023 temp2 = true;
25024 }
25025 }
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25029 wxPyEndAllowThreads(__tstate);
25030 if (PyErr_Occurred()) SWIG_fail;
25031 }
25032 resultobj = SWIG_From_int(static_cast< int >(result));
25033 {
25034 if (temp2) delete arg2;
25035 }
25036 return resultobj;
25037 fail:
25038 {
25039 if (temp2) delete arg2;
25040 }
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25046 PyObject *resultobj = 0;
25047 wxDateTime *arg1 = (wxDateTime *) 0 ;
25048 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25049 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25050 int result;
25051 void *argp1 = 0 ;
25052 int res1 = 0 ;
25053 bool temp2 = false ;
25054 PyObject * obj0 = 0 ;
25055 PyObject * obj1 = 0 ;
25056 char * kwnames[] = {
25057 (char *) "self",(char *) "tz", NULL
25058 };
25059
25060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25062 if (!SWIG_IsOK(res1)) {
25063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25064 }
25065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25066 if (obj1) {
25067 {
25068 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25069 temp2 = true;
25070 }
25071 }
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 resultobj = SWIG_From_int(static_cast< int >(result));
25079 {
25080 if (temp2) delete arg2;
25081 }
25082 return resultobj;
25083 fail:
25084 {
25085 if (temp2) delete arg2;
25086 }
25087 return NULL;
25088 }
25089
25090
25091 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25092 PyObject *resultobj = 0;
25093 wxDateTime *arg1 = (wxDateTime *) 0 ;
25094 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25095 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25096 wxDateTime::WeekDay result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 bool temp2 = false ;
25100 PyObject * obj0 = 0 ;
25101 PyObject * obj1 = 0 ;
25102 char * kwnames[] = {
25103 (char *) "self",(char *) "tz", NULL
25104 };
25105
25106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25108 if (!SWIG_IsOK(res1)) {
25109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25110 }
25111 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25112 if (obj1) {
25113 {
25114 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25115 temp2 = true;
25116 }
25117 }
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 resultobj = SWIG_From_int(static_cast< int >(result));
25125 {
25126 if (temp2) delete arg2;
25127 }
25128 return resultobj;
25129 fail:
25130 {
25131 if (temp2) delete arg2;
25132 }
25133 return NULL;
25134 }
25135
25136
25137 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25138 PyObject *resultobj = 0;
25139 wxDateTime *arg1 = (wxDateTime *) 0 ;
25140 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25141 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25142 int result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 bool temp2 = false ;
25146 PyObject * obj0 = 0 ;
25147 PyObject * obj1 = 0 ;
25148 char * kwnames[] = {
25149 (char *) "self",(char *) "tz", NULL
25150 };
25151
25152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25154 if (!SWIG_IsOK(res1)) {
25155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25156 }
25157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25158 if (obj1) {
25159 {
25160 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25161 temp2 = true;
25162 }
25163 }
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 resultobj = SWIG_From_int(static_cast< int >(result));
25171 {
25172 if (temp2) delete arg2;
25173 }
25174 return resultobj;
25175 fail:
25176 {
25177 if (temp2) delete arg2;
25178 }
25179 return NULL;
25180 }
25181
25182
25183 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25184 PyObject *resultobj = 0;
25185 wxDateTime *arg1 = (wxDateTime *) 0 ;
25186 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25187 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25188 int result;
25189 void *argp1 = 0 ;
25190 int res1 = 0 ;
25191 bool temp2 = false ;
25192 PyObject * obj0 = 0 ;
25193 PyObject * obj1 = 0 ;
25194 char * kwnames[] = {
25195 (char *) "self",(char *) "tz", NULL
25196 };
25197
25198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25200 if (!SWIG_IsOK(res1)) {
25201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25202 }
25203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25204 if (obj1) {
25205 {
25206 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25207 temp2 = true;
25208 }
25209 }
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25213 wxPyEndAllowThreads(__tstate);
25214 if (PyErr_Occurred()) SWIG_fail;
25215 }
25216 resultobj = SWIG_From_int(static_cast< int >(result));
25217 {
25218 if (temp2) delete arg2;
25219 }
25220 return resultobj;
25221 fail:
25222 {
25223 if (temp2) delete arg2;
25224 }
25225 return NULL;
25226 }
25227
25228
25229 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25230 PyObject *resultobj = 0;
25231 wxDateTime *arg1 = (wxDateTime *) 0 ;
25232 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25233 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25234 int result;
25235 void *argp1 = 0 ;
25236 int res1 = 0 ;
25237 bool temp2 = false ;
25238 PyObject * obj0 = 0 ;
25239 PyObject * obj1 = 0 ;
25240 char * kwnames[] = {
25241 (char *) "self",(char *) "tz", NULL
25242 };
25243
25244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25246 if (!SWIG_IsOK(res1)) {
25247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25248 }
25249 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25250 if (obj1) {
25251 {
25252 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25253 temp2 = true;
25254 }
25255 }
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 resultobj = SWIG_From_int(static_cast< int >(result));
25263 {
25264 if (temp2) delete arg2;
25265 }
25266 return resultobj;
25267 fail:
25268 {
25269 if (temp2) delete arg2;
25270 }
25271 return NULL;
25272 }
25273
25274
25275 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25276 PyObject *resultobj = 0;
25277 wxDateTime *arg1 = (wxDateTime *) 0 ;
25278 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25279 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25280 int result;
25281 void *argp1 = 0 ;
25282 int res1 = 0 ;
25283 bool temp2 = false ;
25284 PyObject * obj0 = 0 ;
25285 PyObject * obj1 = 0 ;
25286 char * kwnames[] = {
25287 (char *) "self",(char *) "tz", NULL
25288 };
25289
25290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25292 if (!SWIG_IsOK(res1)) {
25293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25294 }
25295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25296 if (obj1) {
25297 {
25298 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25299 temp2 = true;
25300 }
25301 }
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_From_int(static_cast< int >(result));
25309 {
25310 if (temp2) delete arg2;
25311 }
25312 return resultobj;
25313 fail:
25314 {
25315 if (temp2) delete arg2;
25316 }
25317 return NULL;
25318 }
25319
25320
25321 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25322 PyObject *resultobj = 0;
25323 wxDateTime *arg1 = (wxDateTime *) 0 ;
25324 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25325 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25326 int result;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 bool temp2 = false ;
25330 PyObject * obj0 = 0 ;
25331 PyObject * obj1 = 0 ;
25332 char * kwnames[] = {
25333 (char *) "self",(char *) "tz", NULL
25334 };
25335
25336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25338 if (!SWIG_IsOK(res1)) {
25339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25340 }
25341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25342 if (obj1) {
25343 {
25344 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25345 temp2 = true;
25346 }
25347 }
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 resultobj = SWIG_From_int(static_cast< int >(result));
25355 {
25356 if (temp2) delete arg2;
25357 }
25358 return resultobj;
25359 fail:
25360 {
25361 if (temp2) delete arg2;
25362 }
25363 return NULL;
25364 }
25365
25366
25367 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25368 PyObject *resultobj = 0;
25369 wxDateTime *arg1 = (wxDateTime *) 0 ;
25370 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25371 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25372 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25373 int result;
25374 void *argp1 = 0 ;
25375 int res1 = 0 ;
25376 int val2 ;
25377 int ecode2 = 0 ;
25378 bool temp3 = false ;
25379 PyObject * obj0 = 0 ;
25380 PyObject * obj1 = 0 ;
25381 PyObject * obj2 = 0 ;
25382 char * kwnames[] = {
25383 (char *) "self",(char *) "flags",(char *) "tz", NULL
25384 };
25385
25386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25388 if (!SWIG_IsOK(res1)) {
25389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25390 }
25391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25392 if (obj1) {
25393 ecode2 = SWIG_AsVal_int(obj1, &val2);
25394 if (!SWIG_IsOK(ecode2)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25396 }
25397 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25398 }
25399 if (obj2) {
25400 {
25401 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25402 temp3 = true;
25403 }
25404 }
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 resultobj = SWIG_From_int(static_cast< int >(result));
25412 {
25413 if (temp3) delete arg3;
25414 }
25415 return resultobj;
25416 fail:
25417 {
25418 if (temp3) delete arg3;
25419 }
25420 return NULL;
25421 }
25422
25423
25424 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25425 PyObject *resultobj = 0;
25426 wxDateTime *arg1 = (wxDateTime *) 0 ;
25427 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25428 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25429 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25430 int result;
25431 void *argp1 = 0 ;
25432 int res1 = 0 ;
25433 int val2 ;
25434 int ecode2 = 0 ;
25435 bool temp3 = false ;
25436 PyObject * obj0 = 0 ;
25437 PyObject * obj1 = 0 ;
25438 PyObject * obj2 = 0 ;
25439 char * kwnames[] = {
25440 (char *) "self",(char *) "flags",(char *) "tz", NULL
25441 };
25442
25443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25447 }
25448 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25449 if (obj1) {
25450 ecode2 = SWIG_AsVal_int(obj1, &val2);
25451 if (!SWIG_IsOK(ecode2)) {
25452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25453 }
25454 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25455 }
25456 if (obj2) {
25457 {
25458 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25459 temp3 = true;
25460 }
25461 }
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 resultobj = SWIG_From_int(static_cast< int >(result));
25469 {
25470 if (temp3) delete arg3;
25471 }
25472 return resultobj;
25473 fail:
25474 {
25475 if (temp3) delete arg3;
25476 }
25477 return NULL;
25478 }
25479
25480
25481 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj = 0;
25483 wxDateTime *arg1 = (wxDateTime *) 0 ;
25484 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25485 bool result;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 int val2 ;
25489 int ecode2 = 0 ;
25490 PyObject * obj0 = 0 ;
25491 PyObject * obj1 = 0 ;
25492 char * kwnames[] = {
25493 (char *) "self",(char *) "country", NULL
25494 };
25495
25496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25498 if (!SWIG_IsOK(res1)) {
25499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25500 }
25501 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25502 if (obj1) {
25503 ecode2 = SWIG_AsVal_int(obj1, &val2);
25504 if (!SWIG_IsOK(ecode2)) {
25505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25506 }
25507 arg2 = static_cast< wxDateTime::Country >(val2);
25508 }
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 {
25516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = 0;
25526 wxDateTime *arg1 = (wxDateTime *) 0 ;
25527 wxDateTime *arg2 = 0 ;
25528 bool result;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 void *argp2 = 0 ;
25532 int res2 = 0 ;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 char * kwnames[] = {
25536 (char *) "self",(char *) "datetime", NULL
25537 };
25538
25539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25541 if (!SWIG_IsOK(res1)) {
25542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25543 }
25544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25545 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25546 if (!SWIG_IsOK(res2)) {
25547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25548 }
25549 if (!argp2) {
25550 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25551 }
25552 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25556 wxPyEndAllowThreads(__tstate);
25557 if (PyErr_Occurred()) SWIG_fail;
25558 }
25559 {
25560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25561 }
25562 return resultobj;
25563 fail:
25564 return NULL;
25565 }
25566
25567
25568 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25569 PyObject *resultobj = 0;
25570 wxDateTime *arg1 = (wxDateTime *) 0 ;
25571 wxDateTime *arg2 = 0 ;
25572 bool result;
25573 void *argp1 = 0 ;
25574 int res1 = 0 ;
25575 void *argp2 = 0 ;
25576 int res2 = 0 ;
25577 PyObject * obj0 = 0 ;
25578 PyObject * obj1 = 0 ;
25579 char * kwnames[] = {
25580 (char *) "self",(char *) "datetime", NULL
25581 };
25582
25583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25585 if (!SWIG_IsOK(res1)) {
25586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25587 }
25588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25589 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25590 if (!SWIG_IsOK(res2)) {
25591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25592 }
25593 if (!argp2) {
25594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25595 }
25596 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25597 {
25598 PyThreadState* __tstate = wxPyBeginAllowThreads();
25599 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 {
25604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25605 }
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj = 0;
25614 wxDateTime *arg1 = (wxDateTime *) 0 ;
25615 wxDateTime *arg2 = 0 ;
25616 bool result;
25617 void *argp1 = 0 ;
25618 int res1 = 0 ;
25619 void *argp2 = 0 ;
25620 int res2 = 0 ;
25621 PyObject * obj0 = 0 ;
25622 PyObject * obj1 = 0 ;
25623 char * kwnames[] = {
25624 (char *) "self",(char *) "datetime", NULL
25625 };
25626
25627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25629 if (!SWIG_IsOK(res1)) {
25630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25631 }
25632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25634 if (!SWIG_IsOK(res2)) {
25635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25636 }
25637 if (!argp2) {
25638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25639 }
25640 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 {
25648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25649 }
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25657 PyObject *resultobj = 0;
25658 wxDateTime *arg1 = (wxDateTime *) 0 ;
25659 wxDateTime *arg2 = 0 ;
25660 wxDateTime *arg3 = 0 ;
25661 bool result;
25662 void *argp1 = 0 ;
25663 int res1 = 0 ;
25664 void *argp2 = 0 ;
25665 int res2 = 0 ;
25666 void *argp3 = 0 ;
25667 int res3 = 0 ;
25668 PyObject * obj0 = 0 ;
25669 PyObject * obj1 = 0 ;
25670 PyObject * obj2 = 0 ;
25671 char * kwnames[] = {
25672 (char *) "self",(char *) "t1",(char *) "t2", NULL
25673 };
25674
25675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25677 if (!SWIG_IsOK(res1)) {
25678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25679 }
25680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25682 if (!SWIG_IsOK(res2)) {
25683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25684 }
25685 if (!argp2) {
25686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25687 }
25688 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25689 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25690 if (!SWIG_IsOK(res3)) {
25691 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25692 }
25693 if (!argp3) {
25694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25695 }
25696 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25697 {
25698 PyThreadState* __tstate = wxPyBeginAllowThreads();
25699 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 {
25704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25705 }
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25713 PyObject *resultobj = 0;
25714 wxDateTime *arg1 = (wxDateTime *) 0 ;
25715 wxDateTime *arg2 = 0 ;
25716 wxDateTime *arg3 = 0 ;
25717 bool result;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 void *argp2 = 0 ;
25721 int res2 = 0 ;
25722 void *argp3 = 0 ;
25723 int res3 = 0 ;
25724 PyObject * obj0 = 0 ;
25725 PyObject * obj1 = 0 ;
25726 PyObject * obj2 = 0 ;
25727 char * kwnames[] = {
25728 (char *) "self",(char *) "t1",(char *) "t2", NULL
25729 };
25730
25731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25733 if (!SWIG_IsOK(res1)) {
25734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25735 }
25736 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25738 if (!SWIG_IsOK(res2)) {
25739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25740 }
25741 if (!argp2) {
25742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25743 }
25744 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25745 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25746 if (!SWIG_IsOK(res3)) {
25747 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25748 }
25749 if (!argp3) {
25750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25751 }
25752 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 {
25760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25761 }
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25769 PyObject *resultobj = 0;
25770 wxDateTime *arg1 = (wxDateTime *) 0 ;
25771 wxDateTime *arg2 = 0 ;
25772 bool result;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 void *argp2 = 0 ;
25776 int res2 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 char * kwnames[] = {
25780 (char *) "self",(char *) "dt", NULL
25781 };
25782
25783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25787 }
25788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25789 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25790 if (!SWIG_IsOK(res2)) {
25791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25792 }
25793 if (!argp2) {
25794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25795 }
25796 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxDateTime *arg1 = (wxDateTime *) 0 ;
25815 wxDateTime *arg2 = 0 ;
25816 bool result;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 void *argp2 = 0 ;
25820 int res2 = 0 ;
25821 PyObject * obj0 = 0 ;
25822 PyObject * obj1 = 0 ;
25823 char * kwnames[] = {
25824 (char *) "self",(char *) "dt", NULL
25825 };
25826
25827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25829 if (!SWIG_IsOK(res1)) {
25830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25831 }
25832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25834 if (!SWIG_IsOK(res2)) {
25835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25836 }
25837 if (!argp2) {
25838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25839 }
25840 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 {
25848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25849 }
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj = 0;
25858 wxDateTime *arg1 = (wxDateTime *) 0 ;
25859 wxDateTime *arg2 = 0 ;
25860 wxTimeSpan *arg3 = 0 ;
25861 bool result;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 void *argp2 = 0 ;
25865 int res2 = 0 ;
25866 void *argp3 = 0 ;
25867 int res3 = 0 ;
25868 PyObject * obj0 = 0 ;
25869 PyObject * obj1 = 0 ;
25870 PyObject * obj2 = 0 ;
25871 char * kwnames[] = {
25872 (char *) "self",(char *) "dt",(char *) "ts", NULL
25873 };
25874
25875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25879 }
25880 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25881 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25882 if (!SWIG_IsOK(res2)) {
25883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25884 }
25885 if (!argp2) {
25886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25887 }
25888 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25889 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25890 if (!SWIG_IsOK(res3)) {
25891 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25892 }
25893 if (!argp3) {
25894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25895 }
25896 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 {
25904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25905 }
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj = 0;
25914 wxDateTime *arg1 = (wxDateTime *) 0 ;
25915 wxTimeSpan *arg2 = 0 ;
25916 wxDateTime *result = 0 ;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 void *argp2 = 0 ;
25920 int res2 = 0 ;
25921 PyObject * obj0 = 0 ;
25922 PyObject * obj1 = 0 ;
25923 char * kwnames[] = {
25924 (char *) "self",(char *) "diff", NULL
25925 };
25926
25927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25931 }
25932 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25934 if (!SWIG_IsOK(res2)) {
25935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25936 }
25937 if (!argp2) {
25938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25939 }
25940 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 {
25944 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25945 result = (wxDateTime *) &_result_ref;
25946 }
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxDateTime *arg1 = (wxDateTime *) 0 ;
25960 wxDateSpan *arg2 = 0 ;
25961 wxDateTime *result = 0 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 void *argp2 = 0 ;
25965 int res2 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char * kwnames[] = {
25969 (char *) "self",(char *) "diff", NULL
25970 };
25971
25972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25976 }
25977 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25979 if (!SWIG_IsOK(res2)) {
25980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25981 }
25982 if (!argp2) {
25983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25984 }
25985 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 {
25989 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25990 result = (wxDateTime *) &_result_ref;
25991 }
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxDateTime *arg1 = (wxDateTime *) 0 ;
26005 wxTimeSpan *arg2 = 0 ;
26006 wxDateTime *result = 0 ;
26007 void *argp1 = 0 ;
26008 int res1 = 0 ;
26009 void *argp2 = 0 ;
26010 int res2 = 0 ;
26011 PyObject * obj0 = 0 ;
26012 PyObject * obj1 = 0 ;
26013 char * kwnames[] = {
26014 (char *) "self",(char *) "diff", NULL
26015 };
26016
26017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26019 if (!SWIG_IsOK(res1)) {
26020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26021 }
26022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26023 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26024 if (!SWIG_IsOK(res2)) {
26025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26026 }
26027 if (!argp2) {
26028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26029 }
26030 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 {
26034 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26035 result = (wxDateTime *) &_result_ref;
26036 }
26037 wxPyEndAllowThreads(__tstate);
26038 if (PyErr_Occurred()) SWIG_fail;
26039 }
26040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26048 PyObject *resultobj = 0;
26049 wxDateTime *arg1 = (wxDateTime *) 0 ;
26050 wxDateSpan *arg2 = 0 ;
26051 wxDateTime *result = 0 ;
26052 void *argp1 = 0 ;
26053 int res1 = 0 ;
26054 void *argp2 = 0 ;
26055 int res2 = 0 ;
26056 PyObject * obj0 = 0 ;
26057 PyObject * obj1 = 0 ;
26058 char * kwnames[] = {
26059 (char *) "self",(char *) "diff", NULL
26060 };
26061
26062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26064 if (!SWIG_IsOK(res1)) {
26065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26066 }
26067 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26069 if (!SWIG_IsOK(res2)) {
26070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26071 }
26072 if (!argp2) {
26073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26074 }
26075 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 {
26079 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26080 result = (wxDateTime *) &_result_ref;
26081 }
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj = 0;
26094 wxDateTime *arg1 = (wxDateTime *) 0 ;
26095 wxDateTime *arg2 = 0 ;
26096 wxTimeSpan result;
26097 void *argp1 = 0 ;
26098 int res1 = 0 ;
26099 void *argp2 = 0 ;
26100 int res2 = 0 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 char * kwnames[] = {
26104 (char *) "self",(char *) "dt", NULL
26105 };
26106
26107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26109 if (!SWIG_IsOK(res1)) {
26110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26111 }
26112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26114 if (!SWIG_IsOK(res2)) {
26115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26116 }
26117 if (!argp2) {
26118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26119 }
26120 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26135 PyObject *resultobj = 0;
26136 wxDateTime *arg1 = (wxDateTime *) 0 ;
26137 wxTimeSpan *arg2 = 0 ;
26138 wxDateTime *result = 0 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 void *argp2 = 0 ;
26142 int res2 = 0 ;
26143
26144 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26148 }
26149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26150 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26151 if (!SWIG_IsOK(res2)) {
26152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26153 }
26154 if (!argp2) {
26155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26156 }
26157 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 {
26161 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26162 result = (wxDateTime *) &_result_ref;
26163 }
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26175 PyObject *resultobj = 0;
26176 wxDateTime *arg1 = (wxDateTime *) 0 ;
26177 wxDateSpan *arg2 = 0 ;
26178 wxDateTime *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 void *argp2 = 0 ;
26182 int res2 = 0 ;
26183
26184 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26188 }
26189 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26191 if (!SWIG_IsOK(res2)) {
26192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26193 }
26194 if (!argp2) {
26195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26196 }
26197 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 {
26201 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26202 result = (wxDateTime *) &_result_ref;
26203 }
26204 wxPyEndAllowThreads(__tstate);
26205 if (PyErr_Occurred()) SWIG_fail;
26206 }
26207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26208 return resultobj;
26209 fail:
26210 return NULL;
26211 }
26212
26213
26214 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26215 int argc;
26216 PyObject *argv[3];
26217
26218 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26219 --argc;
26220 if (argc == 2) {
26221 int _v = 0;
26222 {
26223 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26224 _v = SWIG_CheckState(res);
26225 }
26226 if (!_v) goto check_1;
26227 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26228 }
26229 check_1:
26230
26231 if (argc == 2) {
26232 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26233 }
26234
26235 fail:
26236 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26237 return NULL;
26238 }
26239
26240
26241 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26242 PyObject *resultobj = 0;
26243 wxDateTime *arg1 = (wxDateTime *) 0 ;
26244 wxTimeSpan *arg2 = 0 ;
26245 wxDateTime *result = 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 void *argp2 = 0 ;
26249 int res2 = 0 ;
26250
26251 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26255 }
26256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26257 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26258 if (!SWIG_IsOK(res2)) {
26259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26260 }
26261 if (!argp2) {
26262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26263 }
26264 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 {
26268 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26269 result = (wxDateTime *) &_result_ref;
26270 }
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26282 PyObject *resultobj = 0;
26283 wxDateTime *arg1 = (wxDateTime *) 0 ;
26284 wxDateSpan *arg2 = 0 ;
26285 wxDateTime *result = 0 ;
26286 void *argp1 = 0 ;
26287 int res1 = 0 ;
26288 void *argp2 = 0 ;
26289 int res2 = 0 ;
26290
26291 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26293 if (!SWIG_IsOK(res1)) {
26294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26295 }
26296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26297 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26298 if (!SWIG_IsOK(res2)) {
26299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26300 }
26301 if (!argp2) {
26302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26303 }
26304 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 {
26308 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26309 result = (wxDateTime *) &_result_ref;
26310 }
26311 wxPyEndAllowThreads(__tstate);
26312 if (PyErr_Occurred()) SWIG_fail;
26313 }
26314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26315 return resultobj;
26316 fail:
26317 return NULL;
26318 }
26319
26320
26321 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26322 int argc;
26323 PyObject *argv[3];
26324
26325 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26326 --argc;
26327 if (argc == 2) {
26328 int _v = 0;
26329 {
26330 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26331 _v = SWIG_CheckState(res);
26332 }
26333 if (!_v) goto check_1;
26334 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26335 }
26336 check_1:
26337
26338 if (argc == 2) {
26339 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26340 }
26341
26342 fail:
26343 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26349 PyObject *resultobj = 0;
26350 wxDateTime *arg1 = (wxDateTime *) 0 ;
26351 wxTimeSpan *arg2 = 0 ;
26352 wxDateTime result;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 void *argp2 = 0 ;
26356 int res2 = 0 ;
26357
26358 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26360 if (!SWIG_IsOK(res1)) {
26361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26362 }
26363 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26364 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26365 if (!SWIG_IsOK(res2)) {
26366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26367 }
26368 if (!argp2) {
26369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26370 }
26371 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26386 PyObject *resultobj = 0;
26387 wxDateTime *arg1 = (wxDateTime *) 0 ;
26388 wxDateSpan *arg2 = 0 ;
26389 wxDateTime result;
26390 void *argp1 = 0 ;
26391 int res1 = 0 ;
26392 void *argp2 = 0 ;
26393 int res2 = 0 ;
26394
26395 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26397 if (!SWIG_IsOK(res1)) {
26398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26399 }
26400 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26402 if (!SWIG_IsOK(res2)) {
26403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26404 }
26405 if (!argp2) {
26406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26407 }
26408 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26423 int argc;
26424 PyObject *argv[3];
26425
26426 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26427 --argc;
26428 if (argc == 2) {
26429 int _v = 0;
26430 {
26431 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26432 _v = SWIG_CheckState(res);
26433 }
26434 if (!_v) goto check_1;
26435 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26436 }
26437 check_1:
26438
26439 if (argc == 2) {
26440 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26441 }
26442
26443 fail:
26444 Py_INCREF(Py_NotImplemented);
26445 return Py_NotImplemented;
26446 }
26447
26448
26449 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26450 PyObject *resultobj = 0;
26451 wxDateTime *arg1 = (wxDateTime *) 0 ;
26452 wxDateTime *arg2 = 0 ;
26453 wxTimeSpan result;
26454 void *argp1 = 0 ;
26455 int res1 = 0 ;
26456 void *argp2 = 0 ;
26457 int res2 = 0 ;
26458
26459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26461 if (!SWIG_IsOK(res1)) {
26462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26463 }
26464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26465 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26466 if (!SWIG_IsOK(res2)) {
26467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26468 }
26469 if (!argp2) {
26470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26471 }
26472 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26473 {
26474 PyThreadState* __tstate = wxPyBeginAllowThreads();
26475 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26476 wxPyEndAllowThreads(__tstate);
26477 if (PyErr_Occurred()) SWIG_fail;
26478 }
26479 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26480 return resultobj;
26481 fail:
26482 return NULL;
26483 }
26484
26485
26486 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26487 PyObject *resultobj = 0;
26488 wxDateTime *arg1 = (wxDateTime *) 0 ;
26489 wxTimeSpan *arg2 = 0 ;
26490 wxDateTime result;
26491 void *argp1 = 0 ;
26492 int res1 = 0 ;
26493 void *argp2 = 0 ;
26494 int res2 = 0 ;
26495
26496 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26498 if (!SWIG_IsOK(res1)) {
26499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26500 }
26501 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26502 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26503 if (!SWIG_IsOK(res2)) {
26504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26505 }
26506 if (!argp2) {
26507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26508 }
26509 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26517 return resultobj;
26518 fail:
26519 return NULL;
26520 }
26521
26522
26523 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26524 PyObject *resultobj = 0;
26525 wxDateTime *arg1 = (wxDateTime *) 0 ;
26526 wxDateSpan *arg2 = 0 ;
26527 wxDateTime result;
26528 void *argp1 = 0 ;
26529 int res1 = 0 ;
26530 void *argp2 = 0 ;
26531 int res2 = 0 ;
26532
26533 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26535 if (!SWIG_IsOK(res1)) {
26536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26537 }
26538 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26539 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26540 if (!SWIG_IsOK(res2)) {
26541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26542 }
26543 if (!argp2) {
26544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26545 }
26546 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26561 int argc;
26562 PyObject *argv[3];
26563
26564 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26565 --argc;
26566 if (argc == 2) {
26567 int _v = 0;
26568 {
26569 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26570 _v = SWIG_CheckState(res);
26571 }
26572 if (!_v) goto check_1;
26573 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26574 }
26575 check_1:
26576
26577 if (argc == 2) {
26578 int _v = 0;
26579 {
26580 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26581 _v = SWIG_CheckState(res);
26582 }
26583 if (!_v) goto check_2;
26584 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26585 }
26586 check_2:
26587
26588 if (argc == 2) {
26589 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26590 }
26591
26592 fail:
26593 Py_INCREF(Py_NotImplemented);
26594 return Py_NotImplemented;
26595 }
26596
26597
26598 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26599 PyObject *resultobj = 0;
26600 wxDateTime *arg1 = (wxDateTime *) 0 ;
26601 wxDateTime *arg2 = (wxDateTime *) 0 ;
26602 bool result;
26603 void *argp1 = 0 ;
26604 int res1 = 0 ;
26605 void *argp2 = 0 ;
26606 int res2 = 0 ;
26607 PyObject * obj0 = 0 ;
26608 PyObject * obj1 = 0 ;
26609 char * kwnames[] = {
26610 (char *) "self",(char *) "other", NULL
26611 };
26612
26613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26615 if (!SWIG_IsOK(res1)) {
26616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26617 }
26618 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26620 if (!SWIG_IsOK(res2)) {
26621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26622 }
26623 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26624 {
26625 PyThreadState* __tstate = wxPyBeginAllowThreads();
26626 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26627 wxPyEndAllowThreads(__tstate);
26628 if (PyErr_Occurred()) SWIG_fail;
26629 }
26630 {
26631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26632 }
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = 0;
26641 wxDateTime *arg1 = (wxDateTime *) 0 ;
26642 wxDateTime *arg2 = (wxDateTime *) 0 ;
26643 bool result;
26644 void *argp1 = 0 ;
26645 int res1 = 0 ;
26646 void *argp2 = 0 ;
26647 int res2 = 0 ;
26648 PyObject * obj0 = 0 ;
26649 PyObject * obj1 = 0 ;
26650 char * kwnames[] = {
26651 (char *) "self",(char *) "other", NULL
26652 };
26653
26654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26656 if (!SWIG_IsOK(res1)) {
26657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26658 }
26659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26661 if (!SWIG_IsOK(res2)) {
26662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26663 }
26664 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 {
26672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26673 }
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26681 PyObject *resultobj = 0;
26682 wxDateTime *arg1 = (wxDateTime *) 0 ;
26683 wxDateTime *arg2 = (wxDateTime *) 0 ;
26684 bool result;
26685 void *argp1 = 0 ;
26686 int res1 = 0 ;
26687 void *argp2 = 0 ;
26688 int res2 = 0 ;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691 char * kwnames[] = {
26692 (char *) "self",(char *) "other", NULL
26693 };
26694
26695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26699 }
26700 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26702 if (!SWIG_IsOK(res2)) {
26703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26704 }
26705 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 {
26713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26714 }
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj = 0;
26723 wxDateTime *arg1 = (wxDateTime *) 0 ;
26724 wxDateTime *arg2 = (wxDateTime *) 0 ;
26725 bool result;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 void *argp2 = 0 ;
26729 int res2 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "other", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26740 }
26741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26743 if (!SWIG_IsOK(res2)) {
26744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26745 }
26746 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26750 wxPyEndAllowThreads(__tstate);
26751 if (PyErr_Occurred()) SWIG_fail;
26752 }
26753 {
26754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26755 }
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26763 PyObject *resultobj = 0;
26764 wxDateTime *arg1 = (wxDateTime *) 0 ;
26765 wxDateTime *arg2 = (wxDateTime *) 0 ;
26766 bool result;
26767 void *argp1 = 0 ;
26768 int res1 = 0 ;
26769 void *argp2 = 0 ;
26770 int res2 = 0 ;
26771 PyObject * obj0 = 0 ;
26772 PyObject * obj1 = 0 ;
26773 char * kwnames[] = {
26774 (char *) "self",(char *) "other", NULL
26775 };
26776
26777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26781 }
26782 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26784 if (!SWIG_IsOK(res2)) {
26785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26786 }
26787 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26788 {
26789 PyThreadState* __tstate = wxPyBeginAllowThreads();
26790 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 {
26795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26796 }
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26804 PyObject *resultobj = 0;
26805 wxDateTime *arg1 = (wxDateTime *) 0 ;
26806 wxDateTime *arg2 = (wxDateTime *) 0 ;
26807 bool result;
26808 void *argp1 = 0 ;
26809 int res1 = 0 ;
26810 void *argp2 = 0 ;
26811 int res2 = 0 ;
26812 PyObject * obj0 = 0 ;
26813 PyObject * obj1 = 0 ;
26814 char * kwnames[] = {
26815 (char *) "self",(char *) "other", NULL
26816 };
26817
26818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26822 }
26823 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26825 if (!SWIG_IsOK(res2)) {
26826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26827 }
26828 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 {
26836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26837 }
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxDateTime *arg1 = (wxDateTime *) 0 ;
26847 wxString *arg2 = 0 ;
26848 int result;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 bool temp2 = false ;
26852 PyObject * obj0 = 0 ;
26853 PyObject * obj1 = 0 ;
26854 char * kwnames[] = {
26855 (char *) "self",(char *) "date", NULL
26856 };
26857
26858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26860 if (!SWIG_IsOK(res1)) {
26861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26862 }
26863 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26864 {
26865 arg2 = wxString_in_helper(obj1);
26866 if (arg2 == NULL) SWIG_fail;
26867 temp2 = true;
26868 }
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = SWIG_From_int(static_cast< int >(result));
26876 {
26877 if (temp2)
26878 delete arg2;
26879 }
26880 return resultobj;
26881 fail:
26882 {
26883 if (temp2)
26884 delete arg2;
26885 }
26886 return NULL;
26887 }
26888
26889
26890 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26891 PyObject *resultobj = 0;
26892 wxDateTime *arg1 = (wxDateTime *) 0 ;
26893 wxString *arg2 = 0 ;
26894 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26895 wxString *arg3 = (wxString *) &arg3_defvalue ;
26896 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26897 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26898 int result;
26899 void *argp1 = 0 ;
26900 int res1 = 0 ;
26901 bool temp2 = false ;
26902 bool temp3 = false ;
26903 void *argp4 = 0 ;
26904 int res4 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 PyObject * obj2 = 0 ;
26908 PyObject * obj3 = 0 ;
26909 char * kwnames[] = {
26910 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26911 };
26912
26913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26915 if (!SWIG_IsOK(res1)) {
26916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26917 }
26918 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26919 {
26920 arg2 = wxString_in_helper(obj1);
26921 if (arg2 == NULL) SWIG_fail;
26922 temp2 = true;
26923 }
26924 if (obj2) {
26925 {
26926 arg3 = wxString_in_helper(obj2);
26927 if (arg3 == NULL) SWIG_fail;
26928 temp3 = true;
26929 }
26930 }
26931 if (obj3) {
26932 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26933 if (!SWIG_IsOK(res4)) {
26934 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26935 }
26936 if (!argp4) {
26937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26938 }
26939 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26940 }
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26944 wxPyEndAllowThreads(__tstate);
26945 if (PyErr_Occurred()) SWIG_fail;
26946 }
26947 resultobj = SWIG_From_int(static_cast< int >(result));
26948 {
26949 if (temp2)
26950 delete arg2;
26951 }
26952 {
26953 if (temp3)
26954 delete arg3;
26955 }
26956 return resultobj;
26957 fail:
26958 {
26959 if (temp2)
26960 delete arg2;
26961 }
26962 {
26963 if (temp3)
26964 delete arg3;
26965 }
26966 return NULL;
26967 }
26968
26969
26970 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26971 PyObject *resultobj = 0;
26972 wxDateTime *arg1 = (wxDateTime *) 0 ;
26973 wxString *arg2 = 0 ;
26974 int result;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 bool temp2 = false ;
26978 PyObject * obj0 = 0 ;
26979 PyObject * obj1 = 0 ;
26980 char * kwnames[] = {
26981 (char *) "self",(char *) "datetime", NULL
26982 };
26983
26984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26986 if (!SWIG_IsOK(res1)) {
26987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26988 }
26989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26990 {
26991 arg2 = wxString_in_helper(obj1);
26992 if (arg2 == NULL) SWIG_fail;
26993 temp2 = true;
26994 }
26995 {
26996 PyThreadState* __tstate = wxPyBeginAllowThreads();
26997 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26998 wxPyEndAllowThreads(__tstate);
26999 if (PyErr_Occurred()) SWIG_fail;
27000 }
27001 resultobj = SWIG_From_int(static_cast< int >(result));
27002 {
27003 if (temp2)
27004 delete arg2;
27005 }
27006 return resultobj;
27007 fail:
27008 {
27009 if (temp2)
27010 delete arg2;
27011 }
27012 return NULL;
27013 }
27014
27015
27016 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27017 PyObject *resultobj = 0;
27018 wxDateTime *arg1 = (wxDateTime *) 0 ;
27019 wxString *arg2 = 0 ;
27020 int result;
27021 void *argp1 = 0 ;
27022 int res1 = 0 ;
27023 bool temp2 = false ;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 char * kwnames[] = {
27027 (char *) "self",(char *) "date", NULL
27028 };
27029
27030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27032 if (!SWIG_IsOK(res1)) {
27033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27034 }
27035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27036 {
27037 arg2 = wxString_in_helper(obj1);
27038 if (arg2 == NULL) SWIG_fail;
27039 temp2 = true;
27040 }
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 resultobj = SWIG_From_int(static_cast< int >(result));
27048 {
27049 if (temp2)
27050 delete arg2;
27051 }
27052 return resultobj;
27053 fail:
27054 {
27055 if (temp2)
27056 delete arg2;
27057 }
27058 return NULL;
27059 }
27060
27061
27062 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27063 PyObject *resultobj = 0;
27064 wxDateTime *arg1 = (wxDateTime *) 0 ;
27065 wxString *arg2 = 0 ;
27066 int result;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 bool temp2 = false ;
27070 PyObject * obj0 = 0 ;
27071 PyObject * obj1 = 0 ;
27072 char * kwnames[] = {
27073 (char *) "self",(char *) "time", NULL
27074 };
27075
27076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27078 if (!SWIG_IsOK(res1)) {
27079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27080 }
27081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27082 {
27083 arg2 = wxString_in_helper(obj1);
27084 if (arg2 == NULL) SWIG_fail;
27085 temp2 = true;
27086 }
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 resultobj = SWIG_From_int(static_cast< int >(result));
27094 {
27095 if (temp2)
27096 delete arg2;
27097 }
27098 return resultobj;
27099 fail:
27100 {
27101 if (temp2)
27102 delete arg2;
27103 }
27104 return NULL;
27105 }
27106
27107
27108 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj = 0;
27110 wxDateTime *arg1 = (wxDateTime *) 0 ;
27111 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27112 wxString *arg2 = (wxString *) &arg2_defvalue ;
27113 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27114 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27115 wxString result;
27116 void *argp1 = 0 ;
27117 int res1 = 0 ;
27118 bool temp2 = false ;
27119 bool temp3 = false ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 PyObject * obj2 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "self",(char *) "format",(char *) "tz", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27129 if (!SWIG_IsOK(res1)) {
27130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27131 }
27132 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27133 if (obj1) {
27134 {
27135 arg2 = wxString_in_helper(obj1);
27136 if (arg2 == NULL) SWIG_fail;
27137 temp2 = true;
27138 }
27139 }
27140 if (obj2) {
27141 {
27142 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27143 temp3 = true;
27144 }
27145 }
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 {
27153 #if wxUSE_UNICODE
27154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27155 #else
27156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27157 #endif
27158 }
27159 {
27160 if (temp2)
27161 delete arg2;
27162 }
27163 {
27164 if (temp3) delete arg3;
27165 }
27166 return resultobj;
27167 fail:
27168 {
27169 if (temp2)
27170 delete arg2;
27171 }
27172 {
27173 if (temp3) delete arg3;
27174 }
27175 return NULL;
27176 }
27177
27178
27179 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180 PyObject *resultobj = 0;
27181 wxDateTime *arg1 = (wxDateTime *) 0 ;
27182 wxString result;
27183 void *argp1 = 0 ;
27184 int res1 = 0 ;
27185 PyObject *swig_obj[1] ;
27186
27187 if (!args) SWIG_fail;
27188 swig_obj[0] = args;
27189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27190 if (!SWIG_IsOK(res1)) {
27191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27192 }
27193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 result = ((wxDateTime const *)arg1)->FormatDate();
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 {
27201 #if wxUSE_UNICODE
27202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27203 #else
27204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27205 #endif
27206 }
27207 return resultobj;
27208 fail:
27209 return NULL;
27210 }
27211
27212
27213 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27214 PyObject *resultobj = 0;
27215 wxDateTime *arg1 = (wxDateTime *) 0 ;
27216 wxString result;
27217 void *argp1 = 0 ;
27218 int res1 = 0 ;
27219 PyObject *swig_obj[1] ;
27220
27221 if (!args) SWIG_fail;
27222 swig_obj[0] = args;
27223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27224 if (!SWIG_IsOK(res1)) {
27225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27226 }
27227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 result = ((wxDateTime const *)arg1)->FormatTime();
27231 wxPyEndAllowThreads(__tstate);
27232 if (PyErr_Occurred()) SWIG_fail;
27233 }
27234 {
27235 #if wxUSE_UNICODE
27236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27237 #else
27238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27239 #endif
27240 }
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27248 PyObject *resultobj = 0;
27249 wxDateTime *arg1 = (wxDateTime *) 0 ;
27250 wxString result;
27251 void *argp1 = 0 ;
27252 int res1 = 0 ;
27253 PyObject *swig_obj[1] ;
27254
27255 if (!args) SWIG_fail;
27256 swig_obj[0] = args;
27257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27258 if (!SWIG_IsOK(res1)) {
27259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27260 }
27261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27262 {
27263 PyThreadState* __tstate = wxPyBeginAllowThreads();
27264 result = ((wxDateTime const *)arg1)->FormatISODate();
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 {
27269 #if wxUSE_UNICODE
27270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27271 #else
27272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27273 #endif
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27282 PyObject *resultobj = 0;
27283 wxDateTime *arg1 = (wxDateTime *) 0 ;
27284 wxString result;
27285 void *argp1 = 0 ;
27286 int res1 = 0 ;
27287 PyObject *swig_obj[1] ;
27288
27289 if (!args) SWIG_fail;
27290 swig_obj[0] = args;
27291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27294 }
27295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 result = ((wxDateTime const *)arg1)->FormatISOTime();
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 {
27303 #if wxUSE_UNICODE
27304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27305 #else
27306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27307 #endif
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27316 PyObject *obj;
27317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27318 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27319 return SWIG_Py_Void();
27320 }
27321
27322 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27323 return SWIG_Python_InitShadowInstance(args);
27324 }
27325
27326 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 long arg1 ;
27329 wxTimeSpan result;
27330 long val1 ;
27331 int ecode1 = 0 ;
27332 PyObject * obj0 = 0 ;
27333 char * kwnames[] = {
27334 (char *) "ms", NULL
27335 };
27336
27337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27338 ecode1 = SWIG_AsVal_long(obj0, &val1);
27339 if (!SWIG_IsOK(ecode1)) {
27340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27341 }
27342 arg1 = static_cast< long >(val1);
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = wxTimeSpan::Milliseconds(arg1);
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27357 PyObject *resultobj = 0;
27358 wxTimeSpan result;
27359
27360 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = wxTimeSpan::Millisecond();
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj = 0;
27376 long arg1 ;
27377 wxTimeSpan result;
27378 long val1 ;
27379 int ecode1 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 char * kwnames[] = {
27382 (char *) "sec", NULL
27383 };
27384
27385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27386 ecode1 = SWIG_AsVal_long(obj0, &val1);
27387 if (!SWIG_IsOK(ecode1)) {
27388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27389 }
27390 arg1 = static_cast< long >(val1);
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = wxTimeSpan::Seconds(arg1);
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27405 PyObject *resultobj = 0;
27406 wxTimeSpan result;
27407
27408 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = wxTimeSpan::Second();
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27423 PyObject *resultobj = 0;
27424 long arg1 ;
27425 wxTimeSpan result;
27426 long val1 ;
27427 int ecode1 = 0 ;
27428 PyObject * obj0 = 0 ;
27429 char * kwnames[] = {
27430 (char *) "min", NULL
27431 };
27432
27433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27434 ecode1 = SWIG_AsVal_long(obj0, &val1);
27435 if (!SWIG_IsOK(ecode1)) {
27436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27437 }
27438 arg1 = static_cast< long >(val1);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = wxTimeSpan::Minutes(arg1);
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27453 PyObject *resultobj = 0;
27454 wxTimeSpan result;
27455
27456 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = wxTimeSpan::Minute();
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj = 0;
27472 long arg1 ;
27473 wxTimeSpan result;
27474 long val1 ;
27475 int ecode1 = 0 ;
27476 PyObject * obj0 = 0 ;
27477 char * kwnames[] = {
27478 (char *) "hours", NULL
27479 };
27480
27481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27482 ecode1 = SWIG_AsVal_long(obj0, &val1);
27483 if (!SWIG_IsOK(ecode1)) {
27484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27485 }
27486 arg1 = static_cast< long >(val1);
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 result = wxTimeSpan::Hours(arg1);
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *resultobj = 0;
27502 wxTimeSpan result;
27503
27504 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = wxTimeSpan::Hour();
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj = 0;
27520 long arg1 ;
27521 wxTimeSpan result;
27522 long val1 ;
27523 int ecode1 = 0 ;
27524 PyObject * obj0 = 0 ;
27525 char * kwnames[] = {
27526 (char *) "days", NULL
27527 };
27528
27529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27530 ecode1 = SWIG_AsVal_long(obj0, &val1);
27531 if (!SWIG_IsOK(ecode1)) {
27532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27533 }
27534 arg1 = static_cast< long >(val1);
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = wxTimeSpan::Days(arg1);
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 PyObject *resultobj = 0;
27550 wxTimeSpan result;
27551
27552 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 result = wxTimeSpan::Day();
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27567 PyObject *resultobj = 0;
27568 long arg1 ;
27569 wxTimeSpan result;
27570 long val1 ;
27571 int ecode1 = 0 ;
27572 PyObject * obj0 = 0 ;
27573 char * kwnames[] = {
27574 (char *) "days", NULL
27575 };
27576
27577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27578 ecode1 = SWIG_AsVal_long(obj0, &val1);
27579 if (!SWIG_IsOK(ecode1)) {
27580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27581 }
27582 arg1 = static_cast< long >(val1);
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 result = wxTimeSpan::Weeks(arg1);
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27590 return resultobj;
27591 fail:
27592 return NULL;
27593 }
27594
27595
27596 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27597 PyObject *resultobj = 0;
27598 wxTimeSpan result;
27599
27600 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = wxTimeSpan::Week();
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27608 return resultobj;
27609 fail:
27610 return NULL;
27611 }
27612
27613
27614 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27615 PyObject *resultobj = 0;
27616 long arg1 = (long) 0 ;
27617 long arg2 = (long) 0 ;
27618 long arg3 = (long) 0 ;
27619 long arg4 = (long) 0 ;
27620 wxTimeSpan *result = 0 ;
27621 long val1 ;
27622 int ecode1 = 0 ;
27623 long val2 ;
27624 int ecode2 = 0 ;
27625 long val3 ;
27626 int ecode3 = 0 ;
27627 long val4 ;
27628 int ecode4 = 0 ;
27629 PyObject * obj0 = 0 ;
27630 PyObject * obj1 = 0 ;
27631 PyObject * obj2 = 0 ;
27632 PyObject * obj3 = 0 ;
27633 char * kwnames[] = {
27634 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27635 };
27636
27637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27638 if (obj0) {
27639 ecode1 = SWIG_AsVal_long(obj0, &val1);
27640 if (!SWIG_IsOK(ecode1)) {
27641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27642 }
27643 arg1 = static_cast< long >(val1);
27644 }
27645 if (obj1) {
27646 ecode2 = SWIG_AsVal_long(obj1, &val2);
27647 if (!SWIG_IsOK(ecode2)) {
27648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27649 }
27650 arg2 = static_cast< long >(val2);
27651 }
27652 if (obj2) {
27653 ecode3 = SWIG_AsVal_long(obj2, &val3);
27654 if (!SWIG_IsOK(ecode3)) {
27655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27656 }
27657 arg3 = static_cast< long >(val3);
27658 }
27659 if (obj3) {
27660 ecode4 = SWIG_AsVal_long(obj3, &val4);
27661 if (!SWIG_IsOK(ecode4)) {
27662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27663 }
27664 arg4 = static_cast< long >(val4);
27665 }
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680 PyObject *resultobj = 0;
27681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27691 }
27692 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 delete arg1;
27696
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_Py_Void();
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27708 PyObject *resultobj = 0;
27709 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27710 wxTimeSpan *arg2 = 0 ;
27711 wxTimeSpan *result = 0 ;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 void *argp2 = 0 ;
27715 int res2 = 0 ;
27716 PyObject * obj0 = 0 ;
27717 PyObject * obj1 = 0 ;
27718 char * kwnames[] = {
27719 (char *) "self",(char *) "diff", NULL
27720 };
27721
27722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27724 if (!SWIG_IsOK(res1)) {
27725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27726 }
27727 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27728 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27729 if (!SWIG_IsOK(res2)) {
27730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27731 }
27732 if (!argp2) {
27733 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27734 }
27735 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 {
27739 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27740 result = (wxTimeSpan *) &_result_ref;
27741 }
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj = 0;
27754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27755 wxTimeSpan *arg2 = 0 ;
27756 wxTimeSpan *result = 0 ;
27757 void *argp1 = 0 ;
27758 int res1 = 0 ;
27759 void *argp2 = 0 ;
27760 int res2 = 0 ;
27761 PyObject * obj0 = 0 ;
27762 PyObject * obj1 = 0 ;
27763 char * kwnames[] = {
27764 (char *) "self",(char *) "diff", NULL
27765 };
27766
27767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27771 }
27772 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27774 if (!SWIG_IsOK(res2)) {
27775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27776 }
27777 if (!argp2) {
27778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27779 }
27780 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 {
27784 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27785 result = (wxTimeSpan *) &_result_ref;
27786 }
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj = 0;
27799 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27800 int arg2 ;
27801 wxTimeSpan *result = 0 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 int val2 ;
27805 int ecode2 = 0 ;
27806 PyObject * obj0 = 0 ;
27807 PyObject * obj1 = 0 ;
27808 char * kwnames[] = {
27809 (char *) "self",(char *) "n", NULL
27810 };
27811
27812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27814 if (!SWIG_IsOK(res1)) {
27815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27816 }
27817 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27818 ecode2 = SWIG_AsVal_int(obj1, &val2);
27819 if (!SWIG_IsOK(ecode2)) {
27820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27821 }
27822 arg2 = static_cast< int >(val2);
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 {
27826 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27827 result = (wxTimeSpan *) &_result_ref;
27828 }
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27833 return resultobj;
27834 fail:
27835 return NULL;
27836 }
27837
27838
27839 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27840 PyObject *resultobj = 0;
27841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27842 wxTimeSpan *result = 0 ;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 PyObject *swig_obj[1] ;
27846
27847 if (!args) SWIG_fail;
27848 swig_obj[0] = args;
27849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27850 if (!SWIG_IsOK(res1)) {
27851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27852 }
27853 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 {
27857 wxTimeSpan &_result_ref = (arg1)->Neg();
27858 result = (wxTimeSpan *) &_result_ref;
27859 }
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27871 PyObject *resultobj = 0;
27872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27873 wxTimeSpan result;
27874 void *argp1 = 0 ;
27875 int res1 = 0 ;
27876 PyObject *swig_obj[1] ;
27877
27878 if (!args) SWIG_fail;
27879 swig_obj[0] = args;
27880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27881 if (!SWIG_IsOK(res1)) {
27882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27883 }
27884 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 result = ((wxTimeSpan const *)arg1)->Abs();
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj = 0;
27900 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27901 wxTimeSpan *arg2 = 0 ;
27902 wxTimeSpan *result = 0 ;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 void *argp2 = 0 ;
27906 int res2 = 0 ;
27907 PyObject * obj0 = 0 ;
27908 PyObject * obj1 = 0 ;
27909 char * kwnames[] = {
27910 (char *) "self",(char *) "diff", NULL
27911 };
27912
27913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27915 if (!SWIG_IsOK(res1)) {
27916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27917 }
27918 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27920 if (!SWIG_IsOK(res2)) {
27921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27922 }
27923 if (!argp2) {
27924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27925 }
27926 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27927 {
27928 PyThreadState* __tstate = wxPyBeginAllowThreads();
27929 {
27930 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27931 result = (wxTimeSpan *) &_result_ref;
27932 }
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27937 return resultobj;
27938 fail:
27939 return NULL;
27940 }
27941
27942
27943 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27944 PyObject *resultobj = 0;
27945 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27946 wxTimeSpan *arg2 = 0 ;
27947 wxTimeSpan *result = 0 ;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 void *argp2 = 0 ;
27951 int res2 = 0 ;
27952 PyObject * obj0 = 0 ;
27953 PyObject * obj1 = 0 ;
27954 char * kwnames[] = {
27955 (char *) "self",(char *) "diff", NULL
27956 };
27957
27958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27962 }
27963 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27965 if (!SWIG_IsOK(res2)) {
27966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27967 }
27968 if (!argp2) {
27969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27970 }
27971 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 {
27975 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27976 result = (wxTimeSpan *) &_result_ref;
27977 }
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj = 0;
27990 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27991 int arg2 ;
27992 wxTimeSpan *result = 0 ;
27993 void *argp1 = 0 ;
27994 int res1 = 0 ;
27995 int val2 ;
27996 int ecode2 = 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char * kwnames[] = {
28000 (char *) "self",(char *) "n", NULL
28001 };
28002
28003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28005 if (!SWIG_IsOK(res1)) {
28006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28007 }
28008 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28009 ecode2 = SWIG_AsVal_int(obj1, &val2);
28010 if (!SWIG_IsOK(ecode2)) {
28011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28012 }
28013 arg2 = static_cast< int >(val2);
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 {
28017 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28018 result = (wxTimeSpan *) &_result_ref;
28019 }
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28031 PyObject *resultobj = 0;
28032 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28033 wxTimeSpan *result = 0 ;
28034 void *argp1 = 0 ;
28035 int res1 = 0 ;
28036 PyObject *swig_obj[1] ;
28037
28038 if (!args) SWIG_fail;
28039 swig_obj[0] = args;
28040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28041 if (!SWIG_IsOK(res1)) {
28042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28043 }
28044 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 {
28048 wxTimeSpan &_result_ref = (arg1)->operator -();
28049 result = (wxTimeSpan *) &_result_ref;
28050 }
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28062 PyObject *resultobj = 0;
28063 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28064 wxTimeSpan *arg2 = 0 ;
28065 wxTimeSpan result;
28066 void *argp1 = 0 ;
28067 int res1 = 0 ;
28068 void *argp2 = 0 ;
28069 int res2 = 0 ;
28070 PyObject * obj0 = 0 ;
28071 PyObject * obj1 = 0 ;
28072 char * kwnames[] = {
28073 (char *) "self",(char *) "other", NULL
28074 };
28075
28076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28078 if (!SWIG_IsOK(res1)) {
28079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28080 }
28081 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28083 if (!SWIG_IsOK(res2)) {
28084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28085 }
28086 if (!argp2) {
28087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28088 }
28089 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28106 wxTimeSpan *arg2 = 0 ;
28107 wxTimeSpan result;
28108 void *argp1 = 0 ;
28109 int res1 = 0 ;
28110 void *argp2 = 0 ;
28111 int res2 = 0 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char * kwnames[] = {
28115 (char *) "self",(char *) "other", NULL
28116 };
28117
28118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28120 if (!SWIG_IsOK(res1)) {
28121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28122 }
28123 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28124 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28125 if (!SWIG_IsOK(res2)) {
28126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28127 }
28128 if (!argp2) {
28129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28130 }
28131 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28146 PyObject *resultobj = 0;
28147 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28148 int arg2 ;
28149 wxTimeSpan result;
28150 void *argp1 = 0 ;
28151 int res1 = 0 ;
28152 int val2 ;
28153 int ecode2 = 0 ;
28154 PyObject * obj0 = 0 ;
28155 PyObject * obj1 = 0 ;
28156 char * kwnames[] = {
28157 (char *) "self",(char *) "n", NULL
28158 };
28159
28160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28162 if (!SWIG_IsOK(res1)) {
28163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28164 }
28165 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28166 ecode2 = SWIG_AsVal_int(obj1, &val2);
28167 if (!SWIG_IsOK(ecode2)) {
28168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28169 }
28170 arg2 = static_cast< int >(val2);
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = wxTimeSpan___mul__(arg1,arg2);
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28185 PyObject *resultobj = 0;
28186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28187 int arg2 ;
28188 wxTimeSpan result;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 int val2 ;
28192 int ecode2 = 0 ;
28193 PyObject * obj0 = 0 ;
28194 PyObject * obj1 = 0 ;
28195 char * kwnames[] = {
28196 (char *) "self",(char *) "n", NULL
28197 };
28198
28199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28201 if (!SWIG_IsOK(res1)) {
28202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28203 }
28204 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28205 ecode2 = SWIG_AsVal_int(obj1, &val2);
28206 if (!SWIG_IsOK(ecode2)) {
28207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28208 }
28209 arg2 = static_cast< int >(val2);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = wxTimeSpan___rmul__(arg1,arg2);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj = 0;
28225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28226 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28227 bool result;
28228 void *argp1 = 0 ;
28229 int res1 = 0 ;
28230 void *argp2 = 0 ;
28231 int res2 = 0 ;
28232 PyObject * obj0 = 0 ;
28233 PyObject * obj1 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "self",(char *) "other", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28242 }
28243 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28245 if (!SWIG_IsOK(res2)) {
28246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28247 }
28248 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 {
28256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28257 }
28258 return resultobj;
28259 fail:
28260 return NULL;
28261 }
28262
28263
28264 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28265 PyObject *resultobj = 0;
28266 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28267 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28268 bool result;
28269 void *argp1 = 0 ;
28270 int res1 = 0 ;
28271 void *argp2 = 0 ;
28272 int res2 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char * kwnames[] = {
28276 (char *) "self",(char *) "other", NULL
28277 };
28278
28279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28281 if (!SWIG_IsOK(res1)) {
28282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28283 }
28284 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28286 if (!SWIG_IsOK(res2)) {
28287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28288 }
28289 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28293 wxPyEndAllowThreads(__tstate);
28294 if (PyErr_Occurred()) SWIG_fail;
28295 }
28296 {
28297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28298 }
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28306 PyObject *resultobj = 0;
28307 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28308 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28309 bool result;
28310 void *argp1 = 0 ;
28311 int res1 = 0 ;
28312 void *argp2 = 0 ;
28313 int res2 = 0 ;
28314 PyObject * obj0 = 0 ;
28315 PyObject * obj1 = 0 ;
28316 char * kwnames[] = {
28317 (char *) "self",(char *) "other", NULL
28318 };
28319
28320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28322 if (!SWIG_IsOK(res1)) {
28323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28324 }
28325 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28327 if (!SWIG_IsOK(res2)) {
28328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28329 }
28330 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 {
28338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28339 }
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28347 PyObject *resultobj = 0;
28348 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28349 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28350 bool result;
28351 void *argp1 = 0 ;
28352 int res1 = 0 ;
28353 void *argp2 = 0 ;
28354 int res2 = 0 ;
28355 PyObject * obj0 = 0 ;
28356 PyObject * obj1 = 0 ;
28357 char * kwnames[] = {
28358 (char *) "self",(char *) "other", NULL
28359 };
28360
28361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28363 if (!SWIG_IsOK(res1)) {
28364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28365 }
28366 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28368 if (!SWIG_IsOK(res2)) {
28369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28370 }
28371 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 {
28379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28380 }
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj = 0;
28389 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28390 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28391 bool result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 void *argp2 = 0 ;
28395 int res2 = 0 ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char * kwnames[] = {
28399 (char *) "self",(char *) "other", NULL
28400 };
28401
28402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28404 if (!SWIG_IsOK(res1)) {
28405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28406 }
28407 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28409 if (!SWIG_IsOK(res2)) {
28410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28411 }
28412 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28429 PyObject *resultobj = 0;
28430 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28431 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28432 bool result;
28433 void *argp1 = 0 ;
28434 int res1 = 0 ;
28435 void *argp2 = 0 ;
28436 int res2 = 0 ;
28437 PyObject * obj0 = 0 ;
28438 PyObject * obj1 = 0 ;
28439 char * kwnames[] = {
28440 (char *) "self",(char *) "other", NULL
28441 };
28442
28443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28445 if (!SWIG_IsOK(res1)) {
28446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28447 }
28448 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28450 if (!SWIG_IsOK(res2)) {
28451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28452 }
28453 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28470 PyObject *resultobj = 0;
28471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28472 bool result;
28473 void *argp1 = 0 ;
28474 int res1 = 0 ;
28475 PyObject *swig_obj[1] ;
28476
28477 if (!args) SWIG_fail;
28478 swig_obj[0] = args;
28479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28480 if (!SWIG_IsOK(res1)) {
28481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28482 }
28483 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28492 }
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28500 PyObject *resultobj = 0;
28501 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28502 bool result;
28503 void *argp1 = 0 ;
28504 int res1 = 0 ;
28505 PyObject *swig_obj[1] ;
28506
28507 if (!args) SWIG_fail;
28508 swig_obj[0] = args;
28509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28510 if (!SWIG_IsOK(res1)) {
28511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28512 }
28513 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28517 wxPyEndAllowThreads(__tstate);
28518 if (PyErr_Occurred()) SWIG_fail;
28519 }
28520 {
28521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28522 }
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28530 PyObject *resultobj = 0;
28531 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28532 bool result;
28533 void *argp1 = 0 ;
28534 int res1 = 0 ;
28535 PyObject *swig_obj[1] ;
28536
28537 if (!args) SWIG_fail;
28538 swig_obj[0] = args;
28539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28540 if (!SWIG_IsOK(res1)) {
28541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28542 }
28543 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28544 {
28545 PyThreadState* __tstate = wxPyBeginAllowThreads();
28546 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 {
28551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28552 }
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28560 PyObject *resultobj = 0;
28561 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28562 wxTimeSpan *arg2 = 0 ;
28563 bool result;
28564 void *argp1 = 0 ;
28565 int res1 = 0 ;
28566 void *argp2 = 0 ;
28567 int res2 = 0 ;
28568 PyObject * obj0 = 0 ;
28569 PyObject * obj1 = 0 ;
28570 char * kwnames[] = {
28571 (char *) "self",(char *) "ts", NULL
28572 };
28573
28574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28576 if (!SWIG_IsOK(res1)) {
28577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28578 }
28579 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28581 if (!SWIG_IsOK(res2)) {
28582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28583 }
28584 if (!argp2) {
28585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28586 }
28587 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28604 PyObject *resultobj = 0;
28605 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28606 wxTimeSpan *arg2 = 0 ;
28607 bool result;
28608 void *argp1 = 0 ;
28609 int res1 = 0 ;
28610 void *argp2 = 0 ;
28611 int res2 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 PyObject * obj1 = 0 ;
28614 char * kwnames[] = {
28615 (char *) "self",(char *) "ts", NULL
28616 };
28617
28618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28620 if (!SWIG_IsOK(res1)) {
28621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28622 }
28623 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28625 if (!SWIG_IsOK(res2)) {
28626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28627 }
28628 if (!argp2) {
28629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28630 }
28631 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28632 {
28633 PyThreadState* __tstate = wxPyBeginAllowThreads();
28634 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28635 wxPyEndAllowThreads(__tstate);
28636 if (PyErr_Occurred()) SWIG_fail;
28637 }
28638 {
28639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28640 }
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj = 0;
28649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28650 wxTimeSpan *arg2 = 0 ;
28651 bool result;
28652 void *argp1 = 0 ;
28653 int res1 = 0 ;
28654 void *argp2 = 0 ;
28655 int res2 = 0 ;
28656 PyObject * obj0 = 0 ;
28657 PyObject * obj1 = 0 ;
28658 char * kwnames[] = {
28659 (char *) "self",(char *) "t", NULL
28660 };
28661
28662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28664 if (!SWIG_IsOK(res1)) {
28665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28666 }
28667 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28668 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28669 if (!SWIG_IsOK(res2)) {
28670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28671 }
28672 if (!argp2) {
28673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28674 }
28675 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28676 {
28677 PyThreadState* __tstate = wxPyBeginAllowThreads();
28678 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 {
28683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28684 }
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28692 PyObject *resultobj = 0;
28693 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28694 int result;
28695 void *argp1 = 0 ;
28696 int res1 = 0 ;
28697 PyObject *swig_obj[1] ;
28698
28699 if (!args) SWIG_fail;
28700 swig_obj[0] = args;
28701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28702 if (!SWIG_IsOK(res1)) {
28703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28704 }
28705 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_From_int(static_cast< int >(result));
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *resultobj = 0;
28721 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28722 int result;
28723 void *argp1 = 0 ;
28724 int res1 = 0 ;
28725 PyObject *swig_obj[1] ;
28726
28727 if (!args) SWIG_fail;
28728 swig_obj[0] = args;
28729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28730 if (!SWIG_IsOK(res1)) {
28731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28732 }
28733 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 resultobj = SWIG_From_int(static_cast< int >(result));
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28750 int result;
28751 void *argp1 = 0 ;
28752 int res1 = 0 ;
28753 PyObject *swig_obj[1] ;
28754
28755 if (!args) SWIG_fail;
28756 swig_obj[0] = args;
28757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28760 }
28761 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 resultobj = SWIG_From_int(static_cast< int >(result));
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28776 PyObject *resultobj = 0;
28777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28778 int result;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 PyObject *swig_obj[1] ;
28782
28783 if (!args) SWIG_fail;
28784 swig_obj[0] = args;
28785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28786 if (!SWIG_IsOK(res1)) {
28787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28788 }
28789 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28790 {
28791 PyThreadState* __tstate = wxPyBeginAllowThreads();
28792 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 resultobj = SWIG_From_int(static_cast< int >(result));
28797 return resultobj;
28798 fail:
28799 return NULL;
28800 }
28801
28802
28803 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28804 PyObject *resultobj = 0;
28805 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28806 wxLongLong result;
28807 void *argp1 = 0 ;
28808 int res1 = 0 ;
28809 PyObject *swig_obj[1] ;
28810
28811 if (!args) SWIG_fail;
28812 swig_obj[0] = args;
28813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28814 if (!SWIG_IsOK(res1)) {
28815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28816 }
28817 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 {
28825 PyObject *hi, *lo, *shifter, *shifted;
28826 hi = PyLong_FromLong( (&result)->GetHi() );
28827 lo = PyLong_FromLong( (&result)->GetLo() );
28828 shifter = PyLong_FromLong(32);
28829 shifted = PyNumber_Lshift(hi, shifter);
28830 resultobj = PyNumber_Or(shifted, lo);
28831 Py_DECREF(hi);
28832 Py_DECREF(lo);
28833 Py_DECREF(shifter);
28834 Py_DECREF(shifted);
28835 }
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 PyObject *resultobj = 0;
28844 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28845 wxLongLong result;
28846 void *argp1 = 0 ;
28847 int res1 = 0 ;
28848 PyObject *swig_obj[1] ;
28849
28850 if (!args) SWIG_fail;
28851 swig_obj[0] = args;
28852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28853 if (!SWIG_IsOK(res1)) {
28854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28855 }
28856 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 {
28864 PyObject *hi, *lo, *shifter, *shifted;
28865 hi = PyLong_FromLong( (&result)->GetHi() );
28866 lo = PyLong_FromLong( (&result)->GetLo() );
28867 shifter = PyLong_FromLong(32);
28868 shifted = PyNumber_Lshift(hi, shifter);
28869 resultobj = PyNumber_Or(shifted, lo);
28870 Py_DECREF(hi);
28871 Py_DECREF(lo);
28872 Py_DECREF(shifter);
28873 Py_DECREF(shifted);
28874 }
28875 return resultobj;
28876 fail:
28877 return NULL;
28878 }
28879
28880
28881 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj = 0;
28883 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28884 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28885 wxString *arg2 = (wxString *) &arg2_defvalue ;
28886 wxString result;
28887 void *argp1 = 0 ;
28888 int res1 = 0 ;
28889 bool temp2 = false ;
28890 PyObject * obj0 = 0 ;
28891 PyObject * obj1 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "self",(char *) "format", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28898 if (!SWIG_IsOK(res1)) {
28899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28900 }
28901 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28902 if (obj1) {
28903 {
28904 arg2 = wxString_in_helper(obj1);
28905 if (arg2 == NULL) SWIG_fail;
28906 temp2 = true;
28907 }
28908 }
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 #if wxUSE_UNICODE
28917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28918 #else
28919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28920 #endif
28921 }
28922 {
28923 if (temp2)
28924 delete arg2;
28925 }
28926 return resultobj;
28927 fail:
28928 {
28929 if (temp2)
28930 delete arg2;
28931 }
28932 return NULL;
28933 }
28934
28935
28936 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28937 PyObject *obj;
28938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28939 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28940 return SWIG_Py_Void();
28941 }
28942
28943 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 return SWIG_Python_InitShadowInstance(args);
28945 }
28946
28947 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj = 0;
28949 int arg1 = (int) 0 ;
28950 int arg2 = (int) 0 ;
28951 int arg3 = (int) 0 ;
28952 int arg4 = (int) 0 ;
28953 wxDateSpan *result = 0 ;
28954 int val1 ;
28955 int ecode1 = 0 ;
28956 int val2 ;
28957 int ecode2 = 0 ;
28958 int val3 ;
28959 int ecode3 = 0 ;
28960 int val4 ;
28961 int ecode4 = 0 ;
28962 PyObject * obj0 = 0 ;
28963 PyObject * obj1 = 0 ;
28964 PyObject * obj2 = 0 ;
28965 PyObject * obj3 = 0 ;
28966 char * kwnames[] = {
28967 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28968 };
28969
28970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28971 if (obj0) {
28972 ecode1 = SWIG_AsVal_int(obj0, &val1);
28973 if (!SWIG_IsOK(ecode1)) {
28974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28975 }
28976 arg1 = static_cast< int >(val1);
28977 }
28978 if (obj1) {
28979 ecode2 = SWIG_AsVal_int(obj1, &val2);
28980 if (!SWIG_IsOK(ecode2)) {
28981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28982 }
28983 arg2 = static_cast< int >(val2);
28984 }
28985 if (obj2) {
28986 ecode3 = SWIG_AsVal_int(obj2, &val3);
28987 if (!SWIG_IsOK(ecode3)) {
28988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28989 }
28990 arg3 = static_cast< int >(val3);
28991 }
28992 if (obj3) {
28993 ecode4 = SWIG_AsVal_int(obj3, &val4);
28994 if (!SWIG_IsOK(ecode4)) {
28995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28996 }
28997 arg4 = static_cast< int >(val4);
28998 }
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 PyObject *resultobj = 0;
29014 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29015 void *argp1 = 0 ;
29016 int res1 = 0 ;
29017 PyObject *swig_obj[1] ;
29018
29019 if (!args) SWIG_fail;
29020 swig_obj[0] = args;
29021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29022 if (!SWIG_IsOK(res1)) {
29023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29024 }
29025 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 delete arg1;
29029
29030 wxPyEndAllowThreads(__tstate);
29031 if (PyErr_Occurred()) SWIG_fail;
29032 }
29033 resultobj = SWIG_Py_Void();
29034 return resultobj;
29035 fail:
29036 return NULL;
29037 }
29038
29039
29040 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29041 PyObject *resultobj = 0;
29042 int arg1 ;
29043 wxDateSpan result;
29044 int val1 ;
29045 int ecode1 = 0 ;
29046 PyObject * obj0 = 0 ;
29047 char * kwnames[] = {
29048 (char *) "days", NULL
29049 };
29050
29051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29052 ecode1 = SWIG_AsVal_int(obj0, &val1);
29053 if (!SWIG_IsOK(ecode1)) {
29054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29055 }
29056 arg1 = static_cast< int >(val1);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = wxDateSpan::Days(arg1);
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxDateSpan result;
29073
29074 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = wxDateSpan::Day();
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj = 0;
29090 int arg1 ;
29091 wxDateSpan result;
29092 int val1 ;
29093 int ecode1 = 0 ;
29094 PyObject * obj0 = 0 ;
29095 char * kwnames[] = {
29096 (char *) "weeks", NULL
29097 };
29098
29099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29100 ecode1 = SWIG_AsVal_int(obj0, &val1);
29101 if (!SWIG_IsOK(ecode1)) {
29102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29103 }
29104 arg1 = static_cast< int >(val1);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 result = wxDateSpan::Weeks(arg1);
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 PyObject *resultobj = 0;
29120 wxDateSpan result;
29121
29122 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 result = wxDateSpan::Week();
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29137 PyObject *resultobj = 0;
29138 int arg1 ;
29139 wxDateSpan result;
29140 int val1 ;
29141 int ecode1 = 0 ;
29142 PyObject * obj0 = 0 ;
29143 char * kwnames[] = {
29144 (char *) "mon", NULL
29145 };
29146
29147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29148 ecode1 = SWIG_AsVal_int(obj0, &val1);
29149 if (!SWIG_IsOK(ecode1)) {
29150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29151 }
29152 arg1 = static_cast< int >(val1);
29153 {
29154 PyThreadState* __tstate = wxPyBeginAllowThreads();
29155 result = wxDateSpan::Months(arg1);
29156 wxPyEndAllowThreads(__tstate);
29157 if (PyErr_Occurred()) SWIG_fail;
29158 }
29159 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 PyObject *resultobj = 0;
29168 wxDateSpan result;
29169
29170 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = wxDateSpan::Month();
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj = 0;
29186 int arg1 ;
29187 wxDateSpan result;
29188 int val1 ;
29189 int ecode1 = 0 ;
29190 PyObject * obj0 = 0 ;
29191 char * kwnames[] = {
29192 (char *) "years", NULL
29193 };
29194
29195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29196 ecode1 = SWIG_AsVal_int(obj0, &val1);
29197 if (!SWIG_IsOK(ecode1)) {
29198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29199 }
29200 arg1 = static_cast< int >(val1);
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = wxDateSpan::Years(arg1);
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *resultobj = 0;
29216 wxDateSpan result;
29217
29218 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = wxDateSpan::Year();
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj = 0;
29234 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29235 int arg2 ;
29236 wxDateSpan *result = 0 ;
29237 void *argp1 = 0 ;
29238 int res1 = 0 ;
29239 int val2 ;
29240 int ecode2 = 0 ;
29241 PyObject * obj0 = 0 ;
29242 PyObject * obj1 = 0 ;
29243 char * kwnames[] = {
29244 (char *) "self",(char *) "n", NULL
29245 };
29246
29247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29249 if (!SWIG_IsOK(res1)) {
29250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29251 }
29252 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29253 ecode2 = SWIG_AsVal_int(obj1, &val2);
29254 if (!SWIG_IsOK(ecode2)) {
29255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29256 }
29257 arg2 = static_cast< int >(val2);
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 {
29261 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29262 result = (wxDateSpan *) &_result_ref;
29263 }
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29275 PyObject *resultobj = 0;
29276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29277 int arg2 ;
29278 wxDateSpan *result = 0 ;
29279 void *argp1 = 0 ;
29280 int res1 = 0 ;
29281 int val2 ;
29282 int ecode2 = 0 ;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 char * kwnames[] = {
29286 (char *) "self",(char *) "n", NULL
29287 };
29288
29289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29293 }
29294 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29295 ecode2 = SWIG_AsVal_int(obj1, &val2);
29296 if (!SWIG_IsOK(ecode2)) {
29297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29298 }
29299 arg2 = static_cast< int >(val2);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 {
29303 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29304 result = (wxDateSpan *) &_result_ref;
29305 }
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29317 PyObject *resultobj = 0;
29318 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29319 int arg2 ;
29320 wxDateSpan *result = 0 ;
29321 void *argp1 = 0 ;
29322 int res1 = 0 ;
29323 int val2 ;
29324 int ecode2 = 0 ;
29325 PyObject * obj0 = 0 ;
29326 PyObject * obj1 = 0 ;
29327 char * kwnames[] = {
29328 (char *) "self",(char *) "n", NULL
29329 };
29330
29331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29333 if (!SWIG_IsOK(res1)) {
29334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29335 }
29336 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29337 ecode2 = SWIG_AsVal_int(obj1, &val2);
29338 if (!SWIG_IsOK(ecode2)) {
29339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29340 }
29341 arg2 = static_cast< int >(val2);
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 {
29345 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29346 result = (wxDateSpan *) &_result_ref;
29347 }
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29352 return resultobj;
29353 fail:
29354 return NULL;
29355 }
29356
29357
29358 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29359 PyObject *resultobj = 0;
29360 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29361 int arg2 ;
29362 wxDateSpan *result = 0 ;
29363 void *argp1 = 0 ;
29364 int res1 = 0 ;
29365 int val2 ;
29366 int ecode2 = 0 ;
29367 PyObject * obj0 = 0 ;
29368 PyObject * obj1 = 0 ;
29369 char * kwnames[] = {
29370 (char *) "self",(char *) "n", NULL
29371 };
29372
29373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29377 }
29378 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29379 ecode2 = SWIG_AsVal_int(obj1, &val2);
29380 if (!SWIG_IsOK(ecode2)) {
29381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29382 }
29383 arg2 = static_cast< int >(val2);
29384 {
29385 PyThreadState* __tstate = wxPyBeginAllowThreads();
29386 {
29387 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29388 result = (wxDateSpan *) &_result_ref;
29389 }
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29403 int result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject *swig_obj[1] ;
29407
29408 if (!args) SWIG_fail;
29409 swig_obj[0] = args;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29413 }
29414 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (int)((wxDateSpan const *)arg1)->GetYears();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_From_int(static_cast< int >(result));
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29431 int result;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 PyObject *swig_obj[1] ;
29435
29436 if (!args) SWIG_fail;
29437 swig_obj[0] = args;
29438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29439 if (!SWIG_IsOK(res1)) {
29440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29441 }
29442 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29446 wxPyEndAllowThreads(__tstate);
29447 if (PyErr_Occurred()) SWIG_fail;
29448 }
29449 resultobj = SWIG_From_int(static_cast< int >(result));
29450 return resultobj;
29451 fail:
29452 return NULL;
29453 }
29454
29455
29456 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29457 PyObject *resultobj = 0;
29458 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29459 int result;
29460 void *argp1 = 0 ;
29461 int res1 = 0 ;
29462 PyObject *swig_obj[1] ;
29463
29464 if (!args) SWIG_fail;
29465 swig_obj[0] = args;
29466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29467 if (!SWIG_IsOK(res1)) {
29468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29469 }
29470 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 resultobj = SWIG_From_int(static_cast< int >(result));
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29485 PyObject *resultobj = 0;
29486 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29487 int result;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 PyObject *swig_obj[1] ;
29491
29492 if (!args) SWIG_fail;
29493 swig_obj[0] = args;
29494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29497 }
29498 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 result = (int)((wxDateSpan const *)arg1)->GetDays();
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 resultobj = SWIG_From_int(static_cast< int >(result));
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 PyObject *resultobj = 0;
29514 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29515 int result;
29516 void *argp1 = 0 ;
29517 int res1 = 0 ;
29518 PyObject *swig_obj[1] ;
29519
29520 if (!args) SWIG_fail;
29521 swig_obj[0] = args;
29522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29523 if (!SWIG_IsOK(res1)) {
29524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29525 }
29526 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 resultobj = SWIG_From_int(static_cast< int >(result));
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29541 PyObject *resultobj = 0;
29542 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29543 wxDateSpan *arg2 = 0 ;
29544 wxDateSpan *result = 0 ;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 void *argp2 = 0 ;
29548 int res2 = 0 ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 char * kwnames[] = {
29552 (char *) "self",(char *) "other", NULL
29553 };
29554
29555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29557 if (!SWIG_IsOK(res1)) {
29558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29559 }
29560 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29562 if (!SWIG_IsOK(res2)) {
29563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29564 }
29565 if (!argp2) {
29566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29567 }
29568 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29569 {
29570 PyThreadState* __tstate = wxPyBeginAllowThreads();
29571 {
29572 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29573 result = (wxDateSpan *) &_result_ref;
29574 }
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29586 PyObject *resultobj = 0;
29587 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29588 wxDateSpan *arg2 = 0 ;
29589 wxDateSpan *result = 0 ;
29590 void *argp1 = 0 ;
29591 int res1 = 0 ;
29592 void *argp2 = 0 ;
29593 int res2 = 0 ;
29594 PyObject * obj0 = 0 ;
29595 PyObject * obj1 = 0 ;
29596 char * kwnames[] = {
29597 (char *) "self",(char *) "other", NULL
29598 };
29599
29600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29602 if (!SWIG_IsOK(res1)) {
29603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29604 }
29605 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29607 if (!SWIG_IsOK(res2)) {
29608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29609 }
29610 if (!argp2) {
29611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29612 }
29613 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 {
29617 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29618 result = (wxDateSpan *) &_result_ref;
29619 }
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29631 PyObject *resultobj = 0;
29632 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29633 wxDateSpan *result = 0 ;
29634 void *argp1 = 0 ;
29635 int res1 = 0 ;
29636 PyObject *swig_obj[1] ;
29637
29638 if (!args) SWIG_fail;
29639 swig_obj[0] = args;
29640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29641 if (!SWIG_IsOK(res1)) {
29642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29643 }
29644 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 {
29648 wxDateSpan &_result_ref = (arg1)->Neg();
29649 result = (wxDateSpan *) &_result_ref;
29650 }
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj = 0;
29663 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29664 int arg2 ;
29665 wxDateSpan *result = 0 ;
29666 void *argp1 = 0 ;
29667 int res1 = 0 ;
29668 int val2 ;
29669 int ecode2 = 0 ;
29670 PyObject * obj0 = 0 ;
29671 PyObject * obj1 = 0 ;
29672 char * kwnames[] = {
29673 (char *) "self",(char *) "factor", NULL
29674 };
29675
29676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29678 if (!SWIG_IsOK(res1)) {
29679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29680 }
29681 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29682 ecode2 = SWIG_AsVal_int(obj1, &val2);
29683 if (!SWIG_IsOK(ecode2)) {
29684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29685 }
29686 arg2 = static_cast< int >(val2);
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 {
29690 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29691 result = (wxDateSpan *) &_result_ref;
29692 }
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj = 0;
29705 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29706 wxDateSpan *arg2 = 0 ;
29707 wxDateSpan *result = 0 ;
29708 void *argp1 = 0 ;
29709 int res1 = 0 ;
29710 void *argp2 = 0 ;
29711 int res2 = 0 ;
29712 PyObject * obj0 = 0 ;
29713 PyObject * obj1 = 0 ;
29714 char * kwnames[] = {
29715 (char *) "self",(char *) "other", NULL
29716 };
29717
29718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29720 if (!SWIG_IsOK(res1)) {
29721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29722 }
29723 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29725 if (!SWIG_IsOK(res2)) {
29726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29727 }
29728 if (!argp2) {
29729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29730 }
29731 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29732 {
29733 PyThreadState* __tstate = wxPyBeginAllowThreads();
29734 {
29735 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29736 result = (wxDateSpan *) &_result_ref;
29737 }
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29742 return resultobj;
29743 fail:
29744 return NULL;
29745 }
29746
29747
29748 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29749 PyObject *resultobj = 0;
29750 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29751 wxDateSpan *arg2 = 0 ;
29752 wxDateSpan *result = 0 ;
29753 void *argp1 = 0 ;
29754 int res1 = 0 ;
29755 void *argp2 = 0 ;
29756 int res2 = 0 ;
29757 PyObject * obj0 = 0 ;
29758 PyObject * obj1 = 0 ;
29759 char * kwnames[] = {
29760 (char *) "self",(char *) "other", NULL
29761 };
29762
29763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29765 if (!SWIG_IsOK(res1)) {
29766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29767 }
29768 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29770 if (!SWIG_IsOK(res2)) {
29771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29772 }
29773 if (!argp2) {
29774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29775 }
29776 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 {
29780 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29781 result = (wxDateSpan *) &_result_ref;
29782 }
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29796 wxDateSpan *result = 0 ;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29806 }
29807 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 {
29811 wxDateSpan &_result_ref = (arg1)->operator -();
29812 result = (wxDateSpan *) &_result_ref;
29813 }
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29818 return resultobj;
29819 fail:
29820 return NULL;
29821 }
29822
29823
29824 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29825 PyObject *resultobj = 0;
29826 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29827 int arg2 ;
29828 wxDateSpan *result = 0 ;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 int val2 ;
29832 int ecode2 = 0 ;
29833 PyObject * obj0 = 0 ;
29834 PyObject * obj1 = 0 ;
29835 char * kwnames[] = {
29836 (char *) "self",(char *) "factor", NULL
29837 };
29838
29839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29841 if (!SWIG_IsOK(res1)) {
29842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29843 }
29844 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29845 ecode2 = SWIG_AsVal_int(obj1, &val2);
29846 if (!SWIG_IsOK(ecode2)) {
29847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29848 }
29849 arg2 = static_cast< int >(val2);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 {
29853 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29854 result = (wxDateSpan *) &_result_ref;
29855 }
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj = 0;
29868 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29869 wxDateSpan *arg2 = 0 ;
29870 wxDateSpan result;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 void *argp2 = 0 ;
29874 int res2 = 0 ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "other", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29885 }
29886 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29887 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29888 if (!SWIG_IsOK(res2)) {
29889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29890 }
29891 if (!argp2) {
29892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29893 }
29894 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj = 0;
29910 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29911 wxDateSpan *arg2 = 0 ;
29912 wxDateSpan result;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 void *argp2 = 0 ;
29916 int res2 = 0 ;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 char * kwnames[] = {
29920 (char *) "self",(char *) "other", NULL
29921 };
29922
29923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29927 }
29928 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29930 if (!SWIG_IsOK(res2)) {
29931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29932 }
29933 if (!argp2) {
29934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29935 }
29936 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29944 return resultobj;
29945 fail:
29946 return NULL;
29947 }
29948
29949
29950 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29951 PyObject *resultobj = 0;
29952 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29953 int arg2 ;
29954 wxDateSpan result;
29955 void *argp1 = 0 ;
29956 int res1 = 0 ;
29957 int val2 ;
29958 int ecode2 = 0 ;
29959 PyObject * obj0 = 0 ;
29960 PyObject * obj1 = 0 ;
29961 char * kwnames[] = {
29962 (char *) "self",(char *) "n", NULL
29963 };
29964
29965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29967 if (!SWIG_IsOK(res1)) {
29968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29969 }
29970 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29971 ecode2 = SWIG_AsVal_int(obj1, &val2);
29972 if (!SWIG_IsOK(ecode2)) {
29973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29974 }
29975 arg2 = static_cast< int >(val2);
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 result = wxDateSpan___mul__(arg1,arg2);
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj = 0;
29991 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29992 int arg2 ;
29993 wxDateSpan result;
29994 void *argp1 = 0 ;
29995 int res1 = 0 ;
29996 int val2 ;
29997 int ecode2 = 0 ;
29998 PyObject * obj0 = 0 ;
29999 PyObject * obj1 = 0 ;
30000 char * kwnames[] = {
30001 (char *) "self",(char *) "n", NULL
30002 };
30003
30004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30006 if (!SWIG_IsOK(res1)) {
30007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30008 }
30009 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30010 ecode2 = SWIG_AsVal_int(obj1, &val2);
30011 if (!SWIG_IsOK(ecode2)) {
30012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30013 }
30014 arg2 = static_cast< int >(val2);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = wxDateSpan___rmul__(arg1,arg2);
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30022 return resultobj;
30023 fail:
30024 return NULL;
30025 }
30026
30027
30028 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30029 PyObject *resultobj = 0;
30030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30031 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30032 bool result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 void *argp2 = 0 ;
30036 int res2 = 0 ;
30037 PyObject * obj0 = 0 ;
30038 PyObject * obj1 = 0 ;
30039 char * kwnames[] = {
30040 (char *) "self",(char *) "other", NULL
30041 };
30042
30043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30045 if (!SWIG_IsOK(res1)) {
30046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30047 }
30048 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30050 if (!SWIG_IsOK(res2)) {
30051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30052 }
30053 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30057 wxPyEndAllowThreads(__tstate);
30058 if (PyErr_Occurred()) SWIG_fail;
30059 }
30060 {
30061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30062 }
30063 return resultobj;
30064 fail:
30065 return NULL;
30066 }
30067
30068
30069 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30070 PyObject *resultobj = 0;
30071 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30072 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30073 bool result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 void *argp2 = 0 ;
30077 int res2 = 0 ;
30078 PyObject * obj0 = 0 ;
30079 PyObject * obj1 = 0 ;
30080 char * kwnames[] = {
30081 (char *) "self",(char *) "other", NULL
30082 };
30083
30084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30086 if (!SWIG_IsOK(res1)) {
30087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30088 }
30089 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30091 if (!SWIG_IsOK(res2)) {
30092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30093 }
30094 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 {
30102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30103 }
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30111 PyObject *obj;
30112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30113 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30114 return SWIG_Py_Void();
30115 }
30116
30117 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30118 return SWIG_Python_InitShadowInstance(args);
30119 }
30120
30121 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30122 PyObject *resultobj = 0;
30123 long result;
30124
30125 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (long)wxGetLocalTime();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_long(static_cast< long >(result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30140 PyObject *resultobj = 0;
30141 long result;
30142
30143 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 result = (long)wxGetUTCTime();
30147 wxPyEndAllowThreads(__tstate);
30148 if (PyErr_Occurred()) SWIG_fail;
30149 }
30150 resultobj = SWIG_From_long(static_cast< long >(result));
30151 return resultobj;
30152 fail:
30153 return NULL;
30154 }
30155
30156
30157 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30158 PyObject *resultobj = 0;
30159 long result;
30160
30161 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (long)wxGetCurrentTime();
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 resultobj = SWIG_From_long(static_cast< long >(result));
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30176 PyObject *resultobj = 0;
30177 wxLongLong result;
30178
30179 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 result = wxGetLocalTimeMillis();
30183 wxPyEndAllowThreads(__tstate);
30184 if (PyErr_Occurred()) SWIG_fail;
30185 }
30186 {
30187 PyObject *hi, *lo, *shifter, *shifted;
30188 hi = PyLong_FromLong( (&result)->GetHi() );
30189 lo = PyLong_FromLong( (&result)->GetLo() );
30190 shifter = PyLong_FromLong(32);
30191 shifted = PyNumber_Lshift(hi, shifter);
30192 resultobj = PyNumber_Or(shifted, lo);
30193 Py_DECREF(hi);
30194 Py_DECREF(lo);
30195 Py_DECREF(shifter);
30196 Py_DECREF(shifted);
30197 }
30198 return resultobj;
30199 fail:
30200 return NULL;
30201 }
30202
30203
30204 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30205 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30206 return 1;
30207 }
30208
30209
30210 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30211 PyObject *pyobj = 0;
30212
30213 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30214 return pyobj;
30215 }
30216
30217
30218 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj = 0;
30220 wxDataFormatId arg1 ;
30221 wxDataFormat *result = 0 ;
30222 int val1 ;
30223 int ecode1 = 0 ;
30224 PyObject * obj0 = 0 ;
30225 char * kwnames[] = {
30226 (char *) "type", NULL
30227 };
30228
30229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30230 ecode1 = SWIG_AsVal_int(obj0, &val1);
30231 if (!SWIG_IsOK(ecode1)) {
30232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30233 }
30234 arg1 = static_cast< wxDataFormatId >(val1);
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 result = (wxDataFormat *)new wxDataFormat(arg1);
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30249 PyObject *resultobj = 0;
30250 wxString *arg1 = 0 ;
30251 wxDataFormat *result = 0 ;
30252 bool temp1 = false ;
30253 PyObject * obj0 = 0 ;
30254 char * kwnames[] = {
30255 (char *) "format", NULL
30256 };
30257
30258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30259 {
30260 arg1 = wxString_in_helper(obj0);
30261 if (arg1 == NULL) SWIG_fail;
30262 temp1 = true;
30263 }
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30271 {
30272 if (temp1)
30273 delete arg1;
30274 }
30275 return resultobj;
30276 fail:
30277 {
30278 if (temp1)
30279 delete arg1;
30280 }
30281 return NULL;
30282 }
30283
30284
30285 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30286 PyObject *resultobj = 0;
30287 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30288 void *argp1 = 0 ;
30289 int res1 = 0 ;
30290 PyObject *swig_obj[1] ;
30291
30292 if (!args) SWIG_fail;
30293 swig_obj[0] = args;
30294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30295 if (!SWIG_IsOK(res1)) {
30296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30297 }
30298 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 delete arg1;
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 resultobj = SWIG_Py_Void();
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30314 PyObject *resultobj = 0;
30315 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30316 wxDataFormatId arg2 ;
30317 bool result;
30318 void *argp1 = 0 ;
30319 int res1 = 0 ;
30320 int val2 ;
30321 int ecode2 = 0 ;
30322
30323 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30325 if (!SWIG_IsOK(res1)) {
30326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30327 }
30328 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30329 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30330 if (!SWIG_IsOK(ecode2)) {
30331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30332 }
30333 arg2 = static_cast< wxDataFormatId >(val2);
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 {
30341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30342 }
30343 return resultobj;
30344 fail:
30345 return NULL;
30346 }
30347
30348
30349 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30350 PyObject *resultobj = 0;
30351 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30352 wxDataFormatId arg2 ;
30353 bool result;
30354 void *argp1 = 0 ;
30355 int res1 = 0 ;
30356 int val2 ;
30357 int ecode2 = 0 ;
30358
30359 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30361 if (!SWIG_IsOK(res1)) {
30362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30363 }
30364 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30365 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30366 if (!SWIG_IsOK(ecode2)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30368 }
30369 arg2 = static_cast< wxDataFormatId >(val2);
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30386 PyObject *resultobj = 0;
30387 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30388 wxDataFormat *arg2 = 0 ;
30389 bool result;
30390 void *argp1 = 0 ;
30391 int res1 = 0 ;
30392 void *argp2 = 0 ;
30393 int res2 = 0 ;
30394
30395 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30397 if (!SWIG_IsOK(res1)) {
30398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30399 }
30400 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30402 if (!SWIG_IsOK(res2)) {
30403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30404 }
30405 if (!argp2) {
30406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30407 }
30408 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30409 {
30410 PyThreadState* __tstate = wxPyBeginAllowThreads();
30411 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 {
30416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30417 }
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30425 int argc;
30426 PyObject *argv[3];
30427
30428 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30429 --argc;
30430 if (argc == 2) {
30431 int _v = 0;
30432 {
30433 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30434 _v = SWIG_CheckState(res);
30435 }
30436 if (!_v) goto check_1;
30437 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30438 }
30439 check_1:
30440
30441 if (argc == 2) {
30442 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30443 }
30444
30445 fail:
30446 Py_INCREF(Py_NotImplemented);
30447 return Py_NotImplemented;
30448 }
30449
30450
30451 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30452 PyObject *resultobj = 0;
30453 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30454 wxDataFormat *arg2 = 0 ;
30455 bool result;
30456 void *argp1 = 0 ;
30457 int res1 = 0 ;
30458 void *argp2 = 0 ;
30459 int res2 = 0 ;
30460
30461 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30463 if (!SWIG_IsOK(res1)) {
30464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30465 }
30466 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30467 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30468 if (!SWIG_IsOK(res2)) {
30469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30470 }
30471 if (!argp2) {
30472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30473 }
30474 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 {
30482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30491 int argc;
30492 PyObject *argv[3];
30493
30494 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30495 --argc;
30496 if (argc == 2) {
30497 int _v = 0;
30498 {
30499 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30500 _v = SWIG_CheckState(res);
30501 }
30502 if (!_v) goto check_1;
30503 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30504 }
30505 check_1:
30506
30507 if (argc == 2) {
30508 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30509 }
30510
30511 fail:
30512 Py_INCREF(Py_NotImplemented);
30513 return Py_NotImplemented;
30514 }
30515
30516
30517 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30518 PyObject *resultobj = 0;
30519 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30520 wxDataFormatId arg2 ;
30521 void *argp1 = 0 ;
30522 int res1 = 0 ;
30523 int val2 ;
30524 int ecode2 = 0 ;
30525 PyObject * obj0 = 0 ;
30526 PyObject * obj1 = 0 ;
30527 char * kwnames[] = {
30528 (char *) "self",(char *) "format", NULL
30529 };
30530
30531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30533 if (!SWIG_IsOK(res1)) {
30534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30535 }
30536 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30537 ecode2 = SWIG_AsVal_int(obj1, &val2);
30538 if (!SWIG_IsOK(ecode2)) {
30539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30540 }
30541 arg2 = static_cast< wxDataFormatId >(val2);
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 (arg1)->SetType(arg2);
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 resultobj = SWIG_Py_Void();
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30558 wxDataFormatId result;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30568 }
30569 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 resultobj = SWIG_From_int(static_cast< int >(result));
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30586 wxString result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30596 }
30597 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = ((wxDataFormat const *)arg1)->GetId();
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 #if wxUSE_UNICODE
30606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30607 #else
30608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30609 #endif
30610 }
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj = 0;
30619 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30620 wxString *arg2 = 0 ;
30621 void *argp1 = 0 ;
30622 int res1 = 0 ;
30623 bool temp2 = false ;
30624 PyObject * obj0 = 0 ;
30625 PyObject * obj1 = 0 ;
30626 char * kwnames[] = {
30627 (char *) "self",(char *) "format", NULL
30628 };
30629
30630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30632 if (!SWIG_IsOK(res1)) {
30633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30634 }
30635 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30636 {
30637 arg2 = wxString_in_helper(obj1);
30638 if (arg2 == NULL) SWIG_fail;
30639 temp2 = true;
30640 }
30641 {
30642 PyThreadState* __tstate = wxPyBeginAllowThreads();
30643 (arg1)->SetId((wxString const &)*arg2);
30644 wxPyEndAllowThreads(__tstate);
30645 if (PyErr_Occurred()) SWIG_fail;
30646 }
30647 resultobj = SWIG_Py_Void();
30648 {
30649 if (temp2)
30650 delete arg2;
30651 }
30652 return resultobj;
30653 fail:
30654 {
30655 if (temp2)
30656 delete arg2;
30657 }
30658 return NULL;
30659 }
30660
30661
30662 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 PyObject *obj;
30664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30665 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30666 return SWIG_Py_Void();
30667 }
30668
30669 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 return SWIG_Python_InitShadowInstance(args);
30671 }
30672
30673 SWIGINTERN int FormatInvalid_set(PyObject *) {
30674 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30675 return 1;
30676 }
30677
30678
30679 SWIGINTERN PyObject *FormatInvalid_get(void) {
30680 PyObject *pyobj = 0;
30681
30682 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30683 return pyobj;
30684 }
30685
30686
30687 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30688 PyObject *resultobj = 0;
30689 wxDataObject *arg1 = (wxDataObject *) 0 ;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 PyObject *swig_obj[1] ;
30693
30694 if (!args) SWIG_fail;
30695 swig_obj[0] = args;
30696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30699 }
30700 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 delete arg1;
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 resultobj = SWIG_Py_Void();
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30716 PyObject *resultobj = 0;
30717 wxDataObject *arg1 = (wxDataObject *) 0 ;
30718 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30719 SwigValueWrapper<wxDataFormat > result;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 int val2 ;
30723 int ecode2 = 0 ;
30724 PyObject * obj0 = 0 ;
30725 PyObject * obj1 = 0 ;
30726 char * kwnames[] = {
30727 (char *) "self",(char *) "dir", NULL
30728 };
30729
30730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30736 if (obj1) {
30737 ecode2 = SWIG_AsVal_int(obj1, &val2);
30738 if (!SWIG_IsOK(ecode2)) {
30739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30740 }
30741 arg2 = static_cast< wxDataObject::Direction >(val2);
30742 }
30743 {
30744 PyThreadState* __tstate = wxPyBeginAllowThreads();
30745 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30746 wxPyEndAllowThreads(__tstate);
30747 if (PyErr_Occurred()) SWIG_fail;
30748 }
30749 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30757 PyObject *resultobj = 0;
30758 wxDataObject *arg1 = (wxDataObject *) 0 ;
30759 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30760 size_t result;
30761 void *argp1 = 0 ;
30762 int res1 = 0 ;
30763 int val2 ;
30764 int ecode2 = 0 ;
30765 PyObject * obj0 = 0 ;
30766 PyObject * obj1 = 0 ;
30767 char * kwnames[] = {
30768 (char *) "self",(char *) "dir", NULL
30769 };
30770
30771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30773 if (!SWIG_IsOK(res1)) {
30774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30775 }
30776 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30777 if (obj1) {
30778 ecode2 = SWIG_AsVal_int(obj1, &val2);
30779 if (!SWIG_IsOK(ecode2)) {
30780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30781 }
30782 arg2 = static_cast< wxDataObject::Direction >(val2);
30783 }
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30791 return resultobj;
30792 fail:
30793 return NULL;
30794 }
30795
30796
30797 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj = 0;
30799 wxDataObject *arg1 = (wxDataObject *) 0 ;
30800 wxDataFormat *arg2 = 0 ;
30801 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30802 bool result;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 void *argp2 = 0 ;
30806 int res2 = 0 ;
30807 int val3 ;
30808 int ecode3 = 0 ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 PyObject * obj2 = 0 ;
30812 char * kwnames[] = {
30813 (char *) "self",(char *) "format",(char *) "dir", NULL
30814 };
30815
30816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30818 if (!SWIG_IsOK(res1)) {
30819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30820 }
30821 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30822 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30823 if (!SWIG_IsOK(res2)) {
30824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30825 }
30826 if (!argp2) {
30827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30828 }
30829 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30830 if (obj2) {
30831 ecode3 = SWIG_AsVal_int(obj2, &val3);
30832 if (!SWIG_IsOK(ecode3)) {
30833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30834 }
30835 arg3 = static_cast< wxDataObject::Direction >(val3);
30836 }
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 {
30844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30845 }
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj = 0;
30854 wxDataObject *arg1 = (wxDataObject *) 0 ;
30855 wxDataFormat *arg2 = 0 ;
30856 size_t result;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 void *argp2 = 0 ;
30860 int res2 = 0 ;
30861 PyObject * obj0 = 0 ;
30862 PyObject * obj1 = 0 ;
30863 char * kwnames[] = {
30864 (char *) "self",(char *) "format", NULL
30865 };
30866
30867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30869 if (!SWIG_IsOK(res1)) {
30870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30871 }
30872 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30874 if (!SWIG_IsOK(res2)) {
30875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30876 }
30877 if (!argp2) {
30878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30879 }
30880 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30895 PyObject *resultobj = 0;
30896 wxDataObject *arg1 = (wxDataObject *) 0 ;
30897 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30898 PyObject *result = 0 ;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 int val2 ;
30902 int ecode2 = 0 ;
30903 PyObject * obj0 = 0 ;
30904 PyObject * obj1 = 0 ;
30905 char * kwnames[] = {
30906 (char *) "self",(char *) "dir", NULL
30907 };
30908
30909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30911 if (!SWIG_IsOK(res1)) {
30912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30913 }
30914 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30915 if (obj1) {
30916 ecode2 = SWIG_AsVal_int(obj1, &val2);
30917 if (!SWIG_IsOK(ecode2)) {
30918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30919 }
30920 arg2 = static_cast< wxDataObject::Direction >(val2);
30921 }
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 resultobj = result;
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj = 0;
30937 wxDataObject *arg1 = (wxDataObject *) 0 ;
30938 wxDataFormat *arg2 = 0 ;
30939 PyObject *result = 0 ;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 void *argp2 = 0 ;
30943 int res2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "format", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30954 }
30955 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30957 if (!SWIG_IsOK(res2)) {
30958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30959 }
30960 if (!argp2) {
30961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30962 }
30963 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = result;
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj = 0;
30979 wxDataObject *arg1 = (wxDataObject *) 0 ;
30980 wxDataFormat *arg2 = 0 ;
30981 PyObject *arg3 = (PyObject *) 0 ;
30982 bool result;
30983 void *argp1 = 0 ;
30984 int res1 = 0 ;
30985 void *argp2 = 0 ;
30986 int res2 = 0 ;
30987 PyObject * obj0 = 0 ;
30988 PyObject * obj1 = 0 ;
30989 PyObject * obj2 = 0 ;
30990 char * kwnames[] = {
30991 (char *) "self",(char *) "format",(char *) "data", NULL
30992 };
30993
30994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30998 }
30999 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31000 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31001 if (!SWIG_IsOK(res2)) {
31002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31003 }
31004 if (!argp2) {
31005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31006 }
31007 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31008 arg3 = obj2;
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 {
31016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31017 }
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31025 PyObject *obj;
31026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31027 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31028 return SWIG_Py_Void();
31029 }
31030
31031 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31032 PyObject *resultobj = 0;
31033 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31034 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31035 wxDataObjectSimple *result = 0 ;
31036 void *argp1 = 0 ;
31037 int res1 = 0 ;
31038 PyObject * obj0 = 0 ;
31039 char * kwnames[] = {
31040 (char *) "format", NULL
31041 };
31042
31043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31044 if (obj0) {
31045 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31046 if (!SWIG_IsOK(res1)) {
31047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31048 }
31049 if (!argp1) {
31050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31051 }
31052 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31053 }
31054 {
31055 PyThreadState* __tstate = wxPyBeginAllowThreads();
31056 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31068 PyObject *resultobj = 0;
31069 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31070 wxDataFormat *result = 0 ;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 PyObject *swig_obj[1] ;
31074
31075 if (!args) SWIG_fail;
31076 swig_obj[0] = args;
31077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31080 }
31081 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 {
31085 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31086 result = (wxDataFormat *) &_result_ref;
31087 }
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj = 0;
31100 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31101 wxDataFormat *arg2 = 0 ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 void *argp2 = 0 ;
31105 int res2 = 0 ;
31106 PyObject * obj0 = 0 ;
31107 PyObject * obj1 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "format", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31116 }
31117 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31119 if (!SWIG_IsOK(res2)) {
31120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31121 }
31122 if (!argp2) {
31123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31124 }
31125 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_Py_Void();
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31142 size_t result;
31143 void *argp1 = 0 ;
31144 int res1 = 0 ;
31145 PyObject *swig_obj[1] ;
31146
31147 if (!args) SWIG_fail;
31148 swig_obj[0] = args;
31149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31152 }
31153 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31168 PyObject *resultobj = 0;
31169 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31170 PyObject *result = 0 ;
31171 void *argp1 = 0 ;
31172 int res1 = 0 ;
31173 PyObject *swig_obj[1] ;
31174
31175 if (!args) SWIG_fail;
31176 swig_obj[0] = args;
31177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31178 if (!SWIG_IsOK(res1)) {
31179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31180 }
31181 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = result;
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj = 0;
31197 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31198 PyObject *arg2 = (PyObject *) 0 ;
31199 bool result;
31200 void *argp1 = 0 ;
31201 int res1 = 0 ;
31202 PyObject * obj0 = 0 ;
31203 PyObject * obj1 = 0 ;
31204 char * kwnames[] = {
31205 (char *) "self",(char *) "data", NULL
31206 };
31207
31208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31210 if (!SWIG_IsOK(res1)) {
31211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31212 }
31213 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31214 arg2 = obj1;
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 {
31222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31223 }
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 PyObject *obj;
31232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31233 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31234 return SWIG_Py_Void();
31235 }
31236
31237 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31238 return SWIG_Python_InitShadowInstance(args);
31239 }
31240
31241 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31242 PyObject *resultobj = 0;
31243 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31244 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31245 wxPyDataObjectSimple *result = 0 ;
31246 void *argp1 = 0 ;
31247 int res1 = 0 ;
31248 PyObject * obj0 = 0 ;
31249 char * kwnames[] = {
31250 (char *) "format", NULL
31251 };
31252
31253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31254 if (obj0) {
31255 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31256 if (!SWIG_IsOK(res1)) {
31257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31258 }
31259 if (!argp1) {
31260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31261 }
31262 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31280 PyObject *arg2 = (PyObject *) 0 ;
31281 PyObject *arg3 = (PyObject *) 0 ;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 PyObject * obj0 = 0 ;
31285 PyObject * obj1 = 0 ;
31286 PyObject * obj2 = 0 ;
31287 char * kwnames[] = {
31288 (char *) "self",(char *) "self",(char *) "_class", NULL
31289 };
31290
31291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31295 }
31296 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31297 arg2 = obj1;
31298 arg3 = obj2;
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 (arg1)->_setCallbackInfo(arg2,arg3);
31302 wxPyEndAllowThreads(__tstate);
31303 if (PyErr_Occurred()) SWIG_fail;
31304 }
31305 resultobj = SWIG_Py_Void();
31306 return resultobj;
31307 fail:
31308 return NULL;
31309 }
31310
31311
31312 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31313 PyObject *obj;
31314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31315 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31316 return SWIG_Py_Void();
31317 }
31318
31319 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 return SWIG_Python_InitShadowInstance(args);
31321 }
31322
31323 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31324 PyObject *resultobj = 0;
31325 wxDataObjectComposite *result = 0 ;
31326
31327 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31335 return resultobj;
31336 fail:
31337 return NULL;
31338 }
31339
31340
31341 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31342 PyObject *resultobj = 0;
31343 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31344 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31345 bool arg3 = (bool) false ;
31346 void *argp1 = 0 ;
31347 int res1 = 0 ;
31348 int res2 = 0 ;
31349 bool val3 ;
31350 int ecode3 = 0 ;
31351 PyObject * obj0 = 0 ;
31352 PyObject * obj1 = 0 ;
31353 PyObject * obj2 = 0 ;
31354 char * kwnames[] = {
31355 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31356 };
31357
31358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31360 if (!SWIG_IsOK(res1)) {
31361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31362 }
31363 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31364 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31365 if (!SWIG_IsOK(res2)) {
31366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31367 }
31368 if (obj2) {
31369 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31370 if (!SWIG_IsOK(ecode3)) {
31371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31372 }
31373 arg3 = static_cast< bool >(val3);
31374 }
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 (arg1)->Add(arg2,arg3);
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_Py_Void();
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31389 PyObject *resultobj = 0;
31390 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31391 SwigValueWrapper<wxDataFormat > result;
31392 void *argp1 = 0 ;
31393 int res1 = 0 ;
31394 PyObject *swig_obj[1] ;
31395
31396 if (!args) SWIG_fail;
31397 swig_obj[0] = args;
31398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31399 if (!SWIG_IsOK(res1)) {
31400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31401 }
31402 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 PyObject *obj;
31418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31419 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31420 return SWIG_Py_Void();
31421 }
31422
31423 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31424 return SWIG_Python_InitShadowInstance(args);
31425 }
31426
31427 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31428 PyObject *resultobj = 0;
31429 wxString const &arg1_defvalue = wxPyEmptyString ;
31430 wxString *arg1 = (wxString *) &arg1_defvalue ;
31431 wxTextDataObject *result = 0 ;
31432 bool temp1 = false ;
31433 PyObject * obj0 = 0 ;
31434 char * kwnames[] = {
31435 (char *) "text", NULL
31436 };
31437
31438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31439 if (obj0) {
31440 {
31441 arg1 = wxString_in_helper(obj0);
31442 if (arg1 == NULL) SWIG_fail;
31443 temp1 = true;
31444 }
31445 }
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31453 {
31454 if (temp1)
31455 delete arg1;
31456 }
31457 return resultobj;
31458 fail:
31459 {
31460 if (temp1)
31461 delete arg1;
31462 }
31463 return NULL;
31464 }
31465
31466
31467 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31468 PyObject *resultobj = 0;
31469 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31470 size_t result;
31471 void *argp1 = 0 ;
31472 int res1 = 0 ;
31473 PyObject *swig_obj[1] ;
31474
31475 if (!args) SWIG_fail;
31476 swig_obj[0] = args;
31477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31478 if (!SWIG_IsOK(res1)) {
31479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31480 }
31481 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 result = (size_t)(arg1)->GetTextLength();
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31496 PyObject *resultobj = 0;
31497 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31498 wxString result;
31499 void *argp1 = 0 ;
31500 int res1 = 0 ;
31501 PyObject *swig_obj[1] ;
31502
31503 if (!args) SWIG_fail;
31504 swig_obj[0] = args;
31505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31508 }
31509 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = (arg1)->GetText();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 {
31517 #if wxUSE_UNICODE
31518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31519 #else
31520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31521 #endif
31522 }
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31530 PyObject *resultobj = 0;
31531 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31532 wxString *arg2 = 0 ;
31533 void *argp1 = 0 ;
31534 int res1 = 0 ;
31535 bool temp2 = false ;
31536 PyObject * obj0 = 0 ;
31537 PyObject * obj1 = 0 ;
31538 char * kwnames[] = {
31539 (char *) "self",(char *) "text", NULL
31540 };
31541
31542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31544 if (!SWIG_IsOK(res1)) {
31545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31546 }
31547 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31548 {
31549 arg2 = wxString_in_helper(obj1);
31550 if (arg2 == NULL) SWIG_fail;
31551 temp2 = true;
31552 }
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 (arg1)->SetText((wxString const &)*arg2);
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_Py_Void();
31560 {
31561 if (temp2)
31562 delete arg2;
31563 }
31564 return resultobj;
31565 fail:
31566 {
31567 if (temp2)
31568 delete arg2;
31569 }
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31575 PyObject *obj;
31576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31577 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31578 return SWIG_Py_Void();
31579 }
31580
31581 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31582 return SWIG_Python_InitShadowInstance(args);
31583 }
31584
31585 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31586 PyObject *resultobj = 0;
31587 wxString const &arg1_defvalue = wxPyEmptyString ;
31588 wxString *arg1 = (wxString *) &arg1_defvalue ;
31589 wxPyTextDataObject *result = 0 ;
31590 bool temp1 = false ;
31591 PyObject * obj0 = 0 ;
31592 char * kwnames[] = {
31593 (char *) "text", NULL
31594 };
31595
31596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31597 if (obj0) {
31598 {
31599 arg1 = wxString_in_helper(obj0);
31600 if (arg1 == NULL) SWIG_fail;
31601 temp1 = true;
31602 }
31603 }
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31611 {
31612 if (temp1)
31613 delete arg1;
31614 }
31615 return resultobj;
31616 fail:
31617 {
31618 if (temp1)
31619 delete arg1;
31620 }
31621 return NULL;
31622 }
31623
31624
31625 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31626 PyObject *resultobj = 0;
31627 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31628 PyObject *arg2 = (PyObject *) 0 ;
31629 PyObject *arg3 = (PyObject *) 0 ;
31630 void *argp1 = 0 ;
31631 int res1 = 0 ;
31632 PyObject * obj0 = 0 ;
31633 PyObject * obj1 = 0 ;
31634 PyObject * obj2 = 0 ;
31635 char * kwnames[] = {
31636 (char *) "self",(char *) "self",(char *) "_class", NULL
31637 };
31638
31639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31641 if (!SWIG_IsOK(res1)) {
31642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31643 }
31644 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31645 arg2 = obj1;
31646 arg3 = obj2;
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 (arg1)->_setCallbackInfo(arg2,arg3);
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_Py_Void();
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *obj;
31662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31663 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31664 return SWIG_Py_Void();
31665 }
31666
31667 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31668 return SWIG_Python_InitShadowInstance(args);
31669 }
31670
31671 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31672 PyObject *resultobj = 0;
31673 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31674 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31675 wxBitmapDataObject *result = 0 ;
31676 void *argp1 = 0 ;
31677 int res1 = 0 ;
31678 PyObject * obj0 = 0 ;
31679 char * kwnames[] = {
31680 (char *) "bitmap", NULL
31681 };
31682
31683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31684 if (obj0) {
31685 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31688 }
31689 if (!argp1) {
31690 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31691 }
31692 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31693 }
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31708 PyObject *resultobj = 0;
31709 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31710 wxBitmap result;
31711 void *argp1 = 0 ;
31712 int res1 = 0 ;
31713 PyObject *swig_obj[1] ;
31714
31715 if (!args) SWIG_fail;
31716 swig_obj[0] = args;
31717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31718 if (!SWIG_IsOK(res1)) {
31719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31720 }
31721 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj = 0;
31737 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31738 wxBitmap *arg2 = 0 ;
31739 void *argp1 = 0 ;
31740 int res1 = 0 ;
31741 void *argp2 = 0 ;
31742 int res2 = 0 ;
31743 PyObject * obj0 = 0 ;
31744 PyObject * obj1 = 0 ;
31745 char * kwnames[] = {
31746 (char *) "self",(char *) "bitmap", NULL
31747 };
31748
31749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31751 if (!SWIG_IsOK(res1)) {
31752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31753 }
31754 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31756 if (!SWIG_IsOK(res2)) {
31757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31758 }
31759 if (!argp2) {
31760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31761 }
31762 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 resultobj = SWIG_Py_Void();
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 PyObject *obj;
31778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31779 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31780 return SWIG_Py_Void();
31781 }
31782
31783 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31784 return SWIG_Python_InitShadowInstance(args);
31785 }
31786
31787 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj = 0;
31789 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31790 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31791 wxPyBitmapDataObject *result = 0 ;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject * obj0 = 0 ;
31795 char * kwnames[] = {
31796 (char *) "bitmap", NULL
31797 };
31798
31799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31800 if (obj0) {
31801 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31802 if (!SWIG_IsOK(res1)) {
31803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31804 }
31805 if (!argp1) {
31806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31807 }
31808 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31809 }
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj = 0;
31825 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31826 PyObject *arg2 = (PyObject *) 0 ;
31827 PyObject *arg3 = (PyObject *) 0 ;
31828 void *argp1 = 0 ;
31829 int res1 = 0 ;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 PyObject * obj2 = 0 ;
31833 char * kwnames[] = {
31834 (char *) "self",(char *) "self",(char *) "_class", NULL
31835 };
31836
31837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31839 if (!SWIG_IsOK(res1)) {
31840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31841 }
31842 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31843 arg2 = obj1;
31844 arg3 = obj2;
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 (arg1)->_setCallbackInfo(arg2,arg3);
31848 wxPyEndAllowThreads(__tstate);
31849 if (PyErr_Occurred()) SWIG_fail;
31850 }
31851 resultobj = SWIG_Py_Void();
31852 return resultobj;
31853 fail:
31854 return NULL;
31855 }
31856
31857
31858 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31859 PyObject *obj;
31860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31861 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31862 return SWIG_Py_Void();
31863 }
31864
31865 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31866 return SWIG_Python_InitShadowInstance(args);
31867 }
31868
31869 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31870 PyObject *resultobj = 0;
31871 wxFileDataObject *result = 0 ;
31872
31873 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (wxFileDataObject *)new wxFileDataObject();
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31888 PyObject *resultobj = 0;
31889 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31890 wxArrayString *result = 0 ;
31891 void *argp1 = 0 ;
31892 int res1 = 0 ;
31893 PyObject *swig_obj[1] ;
31894
31895 if (!args) SWIG_fail;
31896 swig_obj[0] = args;
31897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31900 }
31901 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 {
31905 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31906 result = (wxArrayString *) &_result_ref;
31907 }
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 {
31912 resultobj = wxArrayString2PyList_helper(*result);
31913 }
31914 return resultobj;
31915 fail:
31916 return NULL;
31917 }
31918
31919
31920 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31921 PyObject *resultobj = 0;
31922 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31923 wxString *arg2 = 0 ;
31924 void *argp1 = 0 ;
31925 int res1 = 0 ;
31926 bool temp2 = false ;
31927 PyObject * obj0 = 0 ;
31928 PyObject * obj1 = 0 ;
31929 char * kwnames[] = {
31930 (char *) "self",(char *) "filename", NULL
31931 };
31932
31933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31935 if (!SWIG_IsOK(res1)) {
31936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31937 }
31938 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31939 {
31940 arg2 = wxString_in_helper(obj1);
31941 if (arg2 == NULL) SWIG_fail;
31942 temp2 = true;
31943 }
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 (arg1)->AddFile((wxString const &)*arg2);
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 resultobj = SWIG_Py_Void();
31951 {
31952 if (temp2)
31953 delete arg2;
31954 }
31955 return resultobj;
31956 fail:
31957 {
31958 if (temp2)
31959 delete arg2;
31960 }
31961 return NULL;
31962 }
31963
31964
31965 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 PyObject *obj;
31967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31968 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31969 return SWIG_Py_Void();
31970 }
31971
31972 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31973 return SWIG_Python_InitShadowInstance(args);
31974 }
31975
31976 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31977 PyObject *resultobj = 0;
31978 wxDataFormat *arg1 = 0 ;
31979 wxCustomDataObject *result = 0 ;
31980 void *argp1 = 0 ;
31981 int res1 = 0 ;
31982
31983 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31985 if (!SWIG_IsOK(res1)) {
31986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31987 }
31988 if (!argp1) {
31989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31990 }
31991 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31992 {
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31999 return resultobj;
32000 fail:
32001 return NULL;
32002 }
32003
32004
32005 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32006 PyObject *resultobj = 0;
32007 wxString *arg1 = 0 ;
32008 wxCustomDataObject *result = 0 ;
32009 bool temp1 = false ;
32010
32011 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32012 {
32013 arg1 = wxString_in_helper(swig_obj[0]);
32014 if (arg1 == NULL) SWIG_fail;
32015 temp1 = true;
32016 }
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32024 {
32025 if (temp1)
32026 delete arg1;
32027 }
32028 return resultobj;
32029 fail:
32030 {
32031 if (temp1)
32032 delete arg1;
32033 }
32034 return NULL;
32035 }
32036
32037
32038 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32039 PyObject *resultobj = 0;
32040 wxCustomDataObject *result = 0 ;
32041
32042 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 result = (wxCustomDataObject *)new wxCustomDataObject();
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32057 int argc;
32058 PyObject *argv[2];
32059
32060 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32061 --argc;
32062 if (argc == 0) {
32063 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32064 }
32065 if (argc == 1) {
32066 int _v = 0;
32067 {
32068 {
32069 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32070 }
32071 }
32072 if (!_v) goto check_2;
32073 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32074 }
32075 check_2:
32076
32077 if (argc == 1) {
32078 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32079 }
32080
32081 fail:
32082 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32083 return NULL;
32084 }
32085
32086
32087 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj = 0;
32089 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32090 PyObject *arg2 = (PyObject *) 0 ;
32091 bool result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 PyObject * obj0 = 0 ;
32095 PyObject * obj1 = 0 ;
32096 char * kwnames[] = {
32097 (char *) "self",(char *) "data", NULL
32098 };
32099
32100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32102 if (!SWIG_IsOK(res1)) {
32103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32104 }
32105 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32106 arg2 = obj1;
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32110 wxPyEndAllowThreads(__tstate);
32111 if (PyErr_Occurred()) SWIG_fail;
32112 }
32113 {
32114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32115 }
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32123 PyObject *resultobj = 0;
32124 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32125 size_t result;
32126 void *argp1 = 0 ;
32127 int res1 = 0 ;
32128 PyObject *swig_obj[1] ;
32129
32130 if (!args) SWIG_fail;
32131 swig_obj[0] = args;
32132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32135 }
32136 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (size_t)(arg1)->GetSize();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32151 PyObject *resultobj = 0;
32152 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32153 PyObject *result = 0 ;
32154 void *argp1 = 0 ;
32155 int res1 = 0 ;
32156 PyObject *swig_obj[1] ;
32157
32158 if (!args) SWIG_fail;
32159 swig_obj[0] = args;
32160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32161 if (!SWIG_IsOK(res1)) {
32162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32163 }
32164 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 resultobj = result;
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 PyObject *obj;
32180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32181 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32182 return SWIG_Py_Void();
32183 }
32184
32185 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32186 return SWIG_Python_InitShadowInstance(args);
32187 }
32188
32189 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32190 PyObject *resultobj = 0;
32191 wxURLDataObject *result = 0 ;
32192
32193 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = (wxURLDataObject *)new wxURLDataObject();
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32210 wxString result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32220 }
32221 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (arg1)->GetURL();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229 #if wxUSE_UNICODE
32230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32231 #else
32232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32233 #endif
32234 }
32235 return resultobj;
32236 fail:
32237 return NULL;
32238 }
32239
32240
32241 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32242 PyObject *resultobj = 0;
32243 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32244 wxString *arg2 = 0 ;
32245 void *argp1 = 0 ;
32246 int res1 = 0 ;
32247 bool temp2 = false ;
32248 PyObject * obj0 = 0 ;
32249 PyObject * obj1 = 0 ;
32250 char * kwnames[] = {
32251 (char *) "self",(char *) "url", NULL
32252 };
32253
32254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32256 if (!SWIG_IsOK(res1)) {
32257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32258 }
32259 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32260 {
32261 arg2 = wxString_in_helper(obj1);
32262 if (arg2 == NULL) SWIG_fail;
32263 temp2 = true;
32264 }
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 (arg1)->SetURL((wxString const &)*arg2);
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_Py_Void();
32272 {
32273 if (temp2)
32274 delete arg2;
32275 }
32276 return resultobj;
32277 fail:
32278 {
32279 if (temp2)
32280 delete arg2;
32281 }
32282 return NULL;
32283 }
32284
32285
32286 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32287 PyObject *obj;
32288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32289 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32290 return SWIG_Py_Void();
32291 }
32292
32293 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32294 return SWIG_Python_InitShadowInstance(args);
32295 }
32296
32297 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32298 PyObject *resultobj = 0;
32299 wxMetafileDataObject *result = 0 ;
32300
32301 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32302 {
32303 PyThreadState* __tstate = wxPyBeginAllowThreads();
32304 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32305 wxPyEndAllowThreads(__tstate);
32306 if (PyErr_Occurred()) SWIG_fail;
32307 }
32308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32309 return resultobj;
32310 fail:
32311 return NULL;
32312 }
32313
32314
32315 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32316 PyObject *resultobj = 0;
32317 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32318 wxMetafile *arg2 = 0 ;
32319 void *argp1 = 0 ;
32320 int res1 = 0 ;
32321 void *argp2 = 0 ;
32322 int res2 = 0 ;
32323 PyObject * obj0 = 0 ;
32324 PyObject * obj1 = 0 ;
32325 char * kwnames[] = {
32326 (char *) "self",(char *) "metafile", NULL
32327 };
32328
32329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32331 if (!SWIG_IsOK(res1)) {
32332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32333 }
32334 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32336 if (!SWIG_IsOK(res2)) {
32337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32338 }
32339 if (!argp2) {
32340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32341 }
32342 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 resultobj = SWIG_Py_Void();
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32357 PyObject *resultobj = 0;
32358 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32359 wxMetafile result;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 PyObject *swig_obj[1] ;
32363
32364 if (!args) SWIG_fail;
32365 swig_obj[0] = args;
32366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32367 if (!SWIG_IsOK(res1)) {
32368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32369 }
32370 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32374 wxPyEndAllowThreads(__tstate);
32375 if (PyErr_Occurred()) SWIG_fail;
32376 }
32377 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 PyObject *obj;
32386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32387 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32388 return SWIG_Py_Void();
32389 }
32390
32391 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32392 return SWIG_Python_InitShadowInstance(args);
32393 }
32394
32395 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32396 PyObject *resultobj = 0;
32397 wxDragResult arg1 ;
32398 bool result;
32399 int val1 ;
32400 int ecode1 = 0 ;
32401 PyObject * obj0 = 0 ;
32402 char * kwnames[] = {
32403 (char *) "res", NULL
32404 };
32405
32406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32407 ecode1 = SWIG_AsVal_int(obj0, &val1);
32408 if (!SWIG_IsOK(ecode1)) {
32409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32410 }
32411 arg1 = static_cast< wxDragResult >(val1);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = (bool)wxIsDragResultOk(arg1);
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 {
32419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32420 }
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32428 PyObject *resultobj = 0;
32429 wxWindow *arg1 = (wxWindow *) 0 ;
32430 wxCursor const &arg2_defvalue = wxNullCursor ;
32431 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32432 wxCursor const &arg3_defvalue = wxNullCursor ;
32433 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32434 wxCursor const &arg4_defvalue = wxNullCursor ;
32435 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32436 wxPyDropSource *result = 0 ;
32437 void *argp1 = 0 ;
32438 int res1 = 0 ;
32439 void *argp2 = 0 ;
32440 int res2 = 0 ;
32441 void *argp3 = 0 ;
32442 int res3 = 0 ;
32443 void *argp4 = 0 ;
32444 int res4 = 0 ;
32445 PyObject * obj0 = 0 ;
32446 PyObject * obj1 = 0 ;
32447 PyObject * obj2 = 0 ;
32448 PyObject * obj3 = 0 ;
32449 char * kwnames[] = {
32450 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32451 };
32452
32453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32455 if (!SWIG_IsOK(res1)) {
32456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32457 }
32458 arg1 = reinterpret_cast< wxWindow * >(argp1);
32459 if (obj1) {
32460 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32461 if (!SWIG_IsOK(res2)) {
32462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32463 }
32464 if (!argp2) {
32465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32466 }
32467 arg2 = reinterpret_cast< wxCursor * >(argp2);
32468 }
32469 if (obj2) {
32470 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32471 if (!SWIG_IsOK(res3)) {
32472 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32473 }
32474 if (!argp3) {
32475 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32476 }
32477 arg3 = reinterpret_cast< wxCursor * >(argp3);
32478 }
32479 if (obj3) {
32480 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32481 if (!SWIG_IsOK(res4)) {
32482 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32483 }
32484 if (!argp4) {
32485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32486 }
32487 arg4 = reinterpret_cast< wxCursor * >(argp4);
32488 }
32489 {
32490 PyThreadState* __tstate = wxPyBeginAllowThreads();
32491 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj = 0;
32504 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32505 PyObject *arg2 = (PyObject *) 0 ;
32506 PyObject *arg3 = (PyObject *) 0 ;
32507 int arg4 ;
32508 void *argp1 = 0 ;
32509 int res1 = 0 ;
32510 int val4 ;
32511 int ecode4 = 0 ;
32512 PyObject * obj0 = 0 ;
32513 PyObject * obj1 = 0 ;
32514 PyObject * obj2 = 0 ;
32515 PyObject * obj3 = 0 ;
32516 char * kwnames[] = {
32517 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32518 };
32519
32520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32522 if (!SWIG_IsOK(res1)) {
32523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32524 }
32525 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32526 arg2 = obj1;
32527 arg3 = obj2;
32528 ecode4 = SWIG_AsVal_int(obj3, &val4);
32529 if (!SWIG_IsOK(ecode4)) {
32530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32531 }
32532 arg4 = static_cast< int >(val4);
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 resultobj = SWIG_Py_Void();
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32558 }
32559 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 delete arg1;
32563
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_Py_Void();
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32575 PyObject *resultobj = 0;
32576 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32577 wxDataObject *arg2 = 0 ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 void *argp2 = 0 ;
32581 int res2 = 0 ;
32582 PyObject * obj0 = 0 ;
32583 PyObject * obj1 = 0 ;
32584 char * kwnames[] = {
32585 (char *) "self",(char *) "data", NULL
32586 };
32587
32588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32590 if (!SWIG_IsOK(res1)) {
32591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32592 }
32593 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32595 if (!SWIG_IsOK(res2)) {
32596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32597 }
32598 if (!argp2) {
32599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32600 }
32601 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32602 {
32603 PyThreadState* __tstate = wxPyBeginAllowThreads();
32604 (arg1)->SetData(*arg2);
32605 wxPyEndAllowThreads(__tstate);
32606 if (PyErr_Occurred()) SWIG_fail;
32607 }
32608 resultobj = SWIG_Py_Void();
32609 return resultobj;
32610 fail:
32611 return NULL;
32612 }
32613
32614
32615 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32616 PyObject *resultobj = 0;
32617 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32618 wxDataObject *result = 0 ;
32619 void *argp1 = 0 ;
32620 int res1 = 0 ;
32621 PyObject *swig_obj[1] ;
32622
32623 if (!args) SWIG_fail;
32624 swig_obj[0] = args;
32625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32628 }
32629 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 result = (wxDataObject *)(arg1)->GetDataObject();
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32637 return resultobj;
32638 fail:
32639 return NULL;
32640 }
32641
32642
32643 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32644 PyObject *resultobj = 0;
32645 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32646 wxDragResult arg2 ;
32647 wxCursor *arg3 = 0 ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 int val2 ;
32651 int ecode2 = 0 ;
32652 void *argp3 = 0 ;
32653 int res3 = 0 ;
32654 PyObject * obj0 = 0 ;
32655 PyObject * obj1 = 0 ;
32656 PyObject * obj2 = 0 ;
32657 char * kwnames[] = {
32658 (char *) "self",(char *) "res",(char *) "cursor", NULL
32659 };
32660
32661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32665 }
32666 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32667 ecode2 = SWIG_AsVal_int(obj1, &val2);
32668 if (!SWIG_IsOK(ecode2)) {
32669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32670 }
32671 arg2 = static_cast< wxDragResult >(val2);
32672 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32673 if (!SWIG_IsOK(res3)) {
32674 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32675 }
32676 if (!argp3) {
32677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32678 }
32679 arg3 = reinterpret_cast< wxCursor * >(argp3);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 resultobj = SWIG_Py_Void();
32687 return resultobj;
32688 fail:
32689 return NULL;
32690 }
32691
32692
32693 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32694 PyObject *resultobj = 0;
32695 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32696 int arg2 = (int) wxDrag_CopyOnly ;
32697 wxDragResult result;
32698 void *argp1 = 0 ;
32699 int res1 = 0 ;
32700 int val2 ;
32701 int ecode2 = 0 ;
32702 PyObject * obj0 = 0 ;
32703 PyObject * obj1 = 0 ;
32704 char * kwnames[] = {
32705 (char *) "self",(char *) "flags", NULL
32706 };
32707
32708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32710 if (!SWIG_IsOK(res1)) {
32711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32712 }
32713 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32714 if (obj1) {
32715 ecode2 = SWIG_AsVal_int(obj1, &val2);
32716 if (!SWIG_IsOK(ecode2)) {
32717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32718 }
32719 arg2 = static_cast< int >(val2);
32720 }
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 resultobj = SWIG_From_int(static_cast< int >(result));
32728 return resultobj;
32729 fail:
32730 return NULL;
32731 }
32732
32733
32734 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32735 PyObject *resultobj = 0;
32736 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32737 wxDragResult arg2 ;
32738 bool result;
32739 void *argp1 = 0 ;
32740 int res1 = 0 ;
32741 int val2 ;
32742 int ecode2 = 0 ;
32743 PyObject * obj0 = 0 ;
32744 PyObject * obj1 = 0 ;
32745 char * kwnames[] = {
32746 (char *) "self",(char *) "effect", NULL
32747 };
32748
32749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32751 if (!SWIG_IsOK(res1)) {
32752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32753 }
32754 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32755 ecode2 = SWIG_AsVal_int(obj1, &val2);
32756 if (!SWIG_IsOK(ecode2)) {
32757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32758 }
32759 arg2 = static_cast< wxDragResult >(val2);
32760 {
32761 PyThreadState* __tstate = wxPyBeginAllowThreads();
32762 result = (bool)(arg1)->GiveFeedback(arg2);
32763 wxPyEndAllowThreads(__tstate);
32764 if (PyErr_Occurred()) SWIG_fail;
32765 }
32766 {
32767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32768 }
32769 return resultobj;
32770 fail:
32771 return NULL;
32772 }
32773
32774
32775 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32776 PyObject *obj;
32777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32778 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32779 return SWIG_Py_Void();
32780 }
32781
32782 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32783 return SWIG_Python_InitShadowInstance(args);
32784 }
32785
32786 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32787 PyObject *resultobj = 0;
32788 wxDataObject *arg1 = (wxDataObject *) NULL ;
32789 wxPyDropTarget *result = 0 ;
32790 int res1 = 0 ;
32791 PyObject * obj0 = 0 ;
32792 char * kwnames[] = {
32793 (char *) "dataObject", NULL
32794 };
32795
32796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32797 if (obj0) {
32798 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32799 if (!SWIG_IsOK(res1)) {
32800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32801 }
32802 }
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj = 0;
32818 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32819 PyObject *arg2 = (PyObject *) 0 ;
32820 PyObject *arg3 = (PyObject *) 0 ;
32821 void *argp1 = 0 ;
32822 int res1 = 0 ;
32823 PyObject * obj0 = 0 ;
32824 PyObject * obj1 = 0 ;
32825 PyObject * obj2 = 0 ;
32826 char * kwnames[] = {
32827 (char *) "self",(char *) "self",(char *) "_class", NULL
32828 };
32829
32830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32832 if (!SWIG_IsOK(res1)) {
32833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32834 }
32835 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32836 arg2 = obj1;
32837 arg3 = obj2;
32838 {
32839 PyThreadState* __tstate = wxPyBeginAllowThreads();
32840 (arg1)->_setCallbackInfo(arg2,arg3);
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 resultobj = SWIG_Py_Void();
32845 return resultobj;
32846 fail:
32847 return NULL;
32848 }
32849
32850
32851 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32852 PyObject *resultobj = 0;
32853 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32854 void *argp1 = 0 ;
32855 int res1 = 0 ;
32856 PyObject *swig_obj[1] ;
32857
32858 if (!args) SWIG_fail;
32859 swig_obj[0] = args;
32860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32861 if (!SWIG_IsOK(res1)) {
32862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32863 }
32864 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32865 {
32866 PyThreadState* __tstate = wxPyBeginAllowThreads();
32867 delete arg1;
32868
32869 wxPyEndAllowThreads(__tstate);
32870 if (PyErr_Occurred()) SWIG_fail;
32871 }
32872 resultobj = SWIG_Py_Void();
32873 return resultobj;
32874 fail:
32875 return NULL;
32876 }
32877
32878
32879 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32880 PyObject *resultobj = 0;
32881 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32882 wxDataObject *result = 0 ;
32883 void *argp1 = 0 ;
32884 int res1 = 0 ;
32885 PyObject *swig_obj[1] ;
32886
32887 if (!args) SWIG_fail;
32888 swig_obj[0] = args;
32889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32890 if (!SWIG_IsOK(res1)) {
32891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32892 }
32893 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32894 {
32895 PyThreadState* __tstate = wxPyBeginAllowThreads();
32896 result = (wxDataObject *)(arg1)->GetDataObject();
32897 wxPyEndAllowThreads(__tstate);
32898 if (PyErr_Occurred()) SWIG_fail;
32899 }
32900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32901 return resultobj;
32902 fail:
32903 return NULL;
32904 }
32905
32906
32907 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32908 PyObject *resultobj = 0;
32909 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32910 wxDataObject *arg2 = (wxDataObject *) 0 ;
32911 void *argp1 = 0 ;
32912 int res1 = 0 ;
32913 int res2 = 0 ;
32914 PyObject * obj0 = 0 ;
32915 PyObject * obj1 = 0 ;
32916 char * kwnames[] = {
32917 (char *) "self",(char *) "dataObject", NULL
32918 };
32919
32920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32924 }
32925 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32926 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32927 if (!SWIG_IsOK(res2)) {
32928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32929 }
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 (arg1)->SetDataObject(arg2);
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 resultobj = SWIG_Py_Void();
32937 return resultobj;
32938 fail:
32939 return NULL;
32940 }
32941
32942
32943 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32944 PyObject *resultobj = 0;
32945 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32946 int arg2 ;
32947 int arg3 ;
32948 wxDragResult arg4 ;
32949 wxDragResult result;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 int val2 ;
32953 int ecode2 = 0 ;
32954 int val3 ;
32955 int ecode3 = 0 ;
32956 int val4 ;
32957 int ecode4 = 0 ;
32958 PyObject * obj0 = 0 ;
32959 PyObject * obj1 = 0 ;
32960 PyObject * obj2 = 0 ;
32961 PyObject * obj3 = 0 ;
32962 char * kwnames[] = {
32963 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32964 };
32965
32966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32968 if (!SWIG_IsOK(res1)) {
32969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32970 }
32971 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32972 ecode2 = SWIG_AsVal_int(obj1, &val2);
32973 if (!SWIG_IsOK(ecode2)) {
32974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32975 }
32976 arg2 = static_cast< int >(val2);
32977 ecode3 = SWIG_AsVal_int(obj2, &val3);
32978 if (!SWIG_IsOK(ecode3)) {
32979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32980 }
32981 arg3 = static_cast< int >(val3);
32982 ecode4 = SWIG_AsVal_int(obj3, &val4);
32983 if (!SWIG_IsOK(ecode4)) {
32984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32985 }
32986 arg4 = static_cast< wxDragResult >(val4);
32987 {
32988 PyThreadState* __tstate = wxPyBeginAllowThreads();
32989 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32990 wxPyEndAllowThreads(__tstate);
32991 if (PyErr_Occurred()) SWIG_fail;
32992 }
32993 resultobj = SWIG_From_int(static_cast< int >(result));
32994 return resultobj;
32995 fail:
32996 return NULL;
32997 }
32998
32999
33000 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33001 PyObject *resultobj = 0;
33002 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33003 int arg2 ;
33004 int arg3 ;
33005 wxDragResult arg4 ;
33006 wxDragResult result;
33007 void *argp1 = 0 ;
33008 int res1 = 0 ;
33009 int val2 ;
33010 int ecode2 = 0 ;
33011 int val3 ;
33012 int ecode3 = 0 ;
33013 int val4 ;
33014 int ecode4 = 0 ;
33015 PyObject * obj0 = 0 ;
33016 PyObject * obj1 = 0 ;
33017 PyObject * obj2 = 0 ;
33018 PyObject * obj3 = 0 ;
33019 char * kwnames[] = {
33020 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33021 };
33022
33023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33025 if (!SWIG_IsOK(res1)) {
33026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33027 }
33028 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33029 ecode2 = SWIG_AsVal_int(obj1, &val2);
33030 if (!SWIG_IsOK(ecode2)) {
33031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33032 }
33033 arg2 = static_cast< int >(val2);
33034 ecode3 = SWIG_AsVal_int(obj2, &val3);
33035 if (!SWIG_IsOK(ecode3)) {
33036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33037 }
33038 arg3 = static_cast< int >(val3);
33039 ecode4 = SWIG_AsVal_int(obj3, &val4);
33040 if (!SWIG_IsOK(ecode4)) {
33041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33042 }
33043 arg4 = static_cast< wxDragResult >(val4);
33044 {
33045 PyThreadState* __tstate = wxPyBeginAllowThreads();
33046 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 resultobj = SWIG_From_int(static_cast< int >(result));
33051 return resultobj;
33052 fail:
33053 return NULL;
33054 }
33055
33056
33057 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33058 PyObject *resultobj = 0;
33059 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 PyObject *swig_obj[1] ;
33063
33064 if (!args) SWIG_fail;
33065 swig_obj[0] = args;
33066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33067 if (!SWIG_IsOK(res1)) {
33068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33069 }
33070 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 (arg1)->OnLeave();
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 resultobj = SWIG_Py_Void();
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj = 0;
33086 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33087 int arg2 ;
33088 int arg3 ;
33089 bool result;
33090 void *argp1 = 0 ;
33091 int res1 = 0 ;
33092 int val2 ;
33093 int ecode2 = 0 ;
33094 int val3 ;
33095 int ecode3 = 0 ;
33096 PyObject * obj0 = 0 ;
33097 PyObject * obj1 = 0 ;
33098 PyObject * obj2 = 0 ;
33099 char * kwnames[] = {
33100 (char *) "self",(char *) "x",(char *) "y", NULL
33101 };
33102
33103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33105 if (!SWIG_IsOK(res1)) {
33106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33107 }
33108 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33109 ecode2 = SWIG_AsVal_int(obj1, &val2);
33110 if (!SWIG_IsOK(ecode2)) {
33111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33112 }
33113 arg2 = static_cast< int >(val2);
33114 ecode3 = SWIG_AsVal_int(obj2, &val3);
33115 if (!SWIG_IsOK(ecode3)) {
33116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33117 }
33118 arg3 = static_cast< int >(val3);
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 result = (bool)(arg1)->OnDrop(arg2,arg3);
33122 wxPyEndAllowThreads(__tstate);
33123 if (PyErr_Occurred()) SWIG_fail;
33124 }
33125 {
33126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33127 }
33128 return resultobj;
33129 fail:
33130 return NULL;
33131 }
33132
33133
33134 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33135 PyObject *resultobj = 0;
33136 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33137 bool result;
33138 void *argp1 = 0 ;
33139 int res1 = 0 ;
33140 PyObject *swig_obj[1] ;
33141
33142 if (!args) SWIG_fail;
33143 swig_obj[0] = args;
33144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33147 }
33148 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 result = (bool)(arg1)->GetData();
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 {
33156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33157 }
33158 return resultobj;
33159 fail:
33160 return NULL;
33161 }
33162
33163
33164 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj = 0;
33166 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33167 wxDragResult arg2 ;
33168 void *argp1 = 0 ;
33169 int res1 = 0 ;
33170 int val2 ;
33171 int ecode2 = 0 ;
33172 PyObject * obj0 = 0 ;
33173 PyObject * obj1 = 0 ;
33174 char * kwnames[] = {
33175 (char *) "self",(char *) "action", NULL
33176 };
33177
33178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33180 if (!SWIG_IsOK(res1)) {
33181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33182 }
33183 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33184 ecode2 = SWIG_AsVal_int(obj1, &val2);
33185 if (!SWIG_IsOK(ecode2)) {
33186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33187 }
33188 arg2 = static_cast< wxDragResult >(val2);
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 (arg1)->SetDefaultAction(arg2);
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 resultobj = SWIG_Py_Void();
33196 return resultobj;
33197 fail:
33198 return NULL;
33199 }
33200
33201
33202 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33203 PyObject *resultobj = 0;
33204 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33205 wxDragResult result;
33206 void *argp1 = 0 ;
33207 int res1 = 0 ;
33208 PyObject *swig_obj[1] ;
33209
33210 if (!args) SWIG_fail;
33211 swig_obj[0] = args;
33212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33213 if (!SWIG_IsOK(res1)) {
33214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33215 }
33216 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 result = (wxDragResult)(arg1)->GetDefaultAction();
33220 wxPyEndAllowThreads(__tstate);
33221 if (PyErr_Occurred()) SWIG_fail;
33222 }
33223 resultobj = SWIG_From_int(static_cast< int >(result));
33224 return resultobj;
33225 fail:
33226 return NULL;
33227 }
33228
33229
33230 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33231 PyObject *obj;
33232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33233 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33234 return SWIG_Py_Void();
33235 }
33236
33237 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33238 return SWIG_Python_InitShadowInstance(args);
33239 }
33240
33241 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33242 PyObject *resultobj = 0;
33243 wxPyTextDropTarget *result = 0 ;
33244
33245 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33246 {
33247 PyThreadState* __tstate = wxPyBeginAllowThreads();
33248 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33253 return resultobj;
33254 fail:
33255 return NULL;
33256 }
33257
33258
33259 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33260 PyObject *resultobj = 0;
33261 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33262 PyObject *arg2 = (PyObject *) 0 ;
33263 PyObject *arg3 = (PyObject *) 0 ;
33264 void *argp1 = 0 ;
33265 int res1 = 0 ;
33266 PyObject * obj0 = 0 ;
33267 PyObject * obj1 = 0 ;
33268 PyObject * obj2 = 0 ;
33269 char * kwnames[] = {
33270 (char *) "self",(char *) "self",(char *) "_class", NULL
33271 };
33272
33273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33275 if (!SWIG_IsOK(res1)) {
33276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33277 }
33278 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33279 arg2 = obj1;
33280 arg3 = obj2;
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 (arg1)->_setCallbackInfo(arg2,arg3);
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 resultobj = SWIG_Py_Void();
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33295 PyObject *resultobj = 0;
33296 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33297 int arg2 ;
33298 int arg3 ;
33299 wxString *arg4 = 0 ;
33300 bool result;
33301 void *argp1 = 0 ;
33302 int res1 = 0 ;
33303 int val2 ;
33304 int ecode2 = 0 ;
33305 int val3 ;
33306 int ecode3 = 0 ;
33307 bool temp4 = false ;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 PyObject * obj2 = 0 ;
33311 PyObject * obj3 = 0 ;
33312 char * kwnames[] = {
33313 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33314 };
33315
33316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33318 if (!SWIG_IsOK(res1)) {
33319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33320 }
33321 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33322 ecode2 = SWIG_AsVal_int(obj1, &val2);
33323 if (!SWIG_IsOK(ecode2)) {
33324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33325 }
33326 arg2 = static_cast< int >(val2);
33327 ecode3 = SWIG_AsVal_int(obj2, &val3);
33328 if (!SWIG_IsOK(ecode3)) {
33329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33330 }
33331 arg3 = static_cast< int >(val3);
33332 {
33333 arg4 = wxString_in_helper(obj3);
33334 if (arg4 == NULL) SWIG_fail;
33335 temp4 = true;
33336 }
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 {
33344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33345 }
33346 {
33347 if (temp4)
33348 delete arg4;
33349 }
33350 return resultobj;
33351 fail:
33352 {
33353 if (temp4)
33354 delete arg4;
33355 }
33356 return NULL;
33357 }
33358
33359
33360 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33361 PyObject *resultobj = 0;
33362 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33363 int arg2 ;
33364 int arg3 ;
33365 wxDragResult arg4 ;
33366 wxDragResult result;
33367 void *argp1 = 0 ;
33368 int res1 = 0 ;
33369 int val2 ;
33370 int ecode2 = 0 ;
33371 int val3 ;
33372 int ecode3 = 0 ;
33373 int val4 ;
33374 int ecode4 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 PyObject * obj2 = 0 ;
33378 PyObject * obj3 = 0 ;
33379 char * kwnames[] = {
33380 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33381 };
33382
33383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33387 }
33388 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33389 ecode2 = SWIG_AsVal_int(obj1, &val2);
33390 if (!SWIG_IsOK(ecode2)) {
33391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33392 }
33393 arg2 = static_cast< int >(val2);
33394 ecode3 = SWIG_AsVal_int(obj2, &val3);
33395 if (!SWIG_IsOK(ecode3)) {
33396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33397 }
33398 arg3 = static_cast< int >(val3);
33399 ecode4 = SWIG_AsVal_int(obj3, &val4);
33400 if (!SWIG_IsOK(ecode4)) {
33401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33402 }
33403 arg4 = static_cast< wxDragResult >(val4);
33404 {
33405 PyThreadState* __tstate = wxPyBeginAllowThreads();
33406 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33407 wxPyEndAllowThreads(__tstate);
33408 if (PyErr_Occurred()) SWIG_fail;
33409 }
33410 resultobj = SWIG_From_int(static_cast< int >(result));
33411 return resultobj;
33412 fail:
33413 return NULL;
33414 }
33415
33416
33417 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33418 PyObject *resultobj = 0;
33419 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33420 int arg2 ;
33421 int arg3 ;
33422 wxDragResult arg4 ;
33423 wxDragResult result;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 int val2 ;
33427 int ecode2 = 0 ;
33428 int val3 ;
33429 int ecode3 = 0 ;
33430 int val4 ;
33431 int ecode4 = 0 ;
33432 PyObject * obj0 = 0 ;
33433 PyObject * obj1 = 0 ;
33434 PyObject * obj2 = 0 ;
33435 PyObject * obj3 = 0 ;
33436 char * kwnames[] = {
33437 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33438 };
33439
33440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33444 }
33445 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33446 ecode2 = SWIG_AsVal_int(obj1, &val2);
33447 if (!SWIG_IsOK(ecode2)) {
33448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33449 }
33450 arg2 = static_cast< int >(val2);
33451 ecode3 = SWIG_AsVal_int(obj2, &val3);
33452 if (!SWIG_IsOK(ecode3)) {
33453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33454 }
33455 arg3 = static_cast< int >(val3);
33456 ecode4 = SWIG_AsVal_int(obj3, &val4);
33457 if (!SWIG_IsOK(ecode4)) {
33458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33459 }
33460 arg4 = static_cast< wxDragResult >(val4);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_From_int(static_cast< int >(result));
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *resultobj = 0;
33476 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33477 void *argp1 = 0 ;
33478 int res1 = 0 ;
33479 PyObject *swig_obj[1] ;
33480
33481 if (!args) SWIG_fail;
33482 swig_obj[0] = args;
33483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33484 if (!SWIG_IsOK(res1)) {
33485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33486 }
33487 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33488 {
33489 PyThreadState* __tstate = wxPyBeginAllowThreads();
33490 (arg1)->OnLeave();
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 resultobj = SWIG_Py_Void();
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33502 PyObject *resultobj = 0;
33503 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33504 int arg2 ;
33505 int arg3 ;
33506 bool result;
33507 void *argp1 = 0 ;
33508 int res1 = 0 ;
33509 int val2 ;
33510 int ecode2 = 0 ;
33511 int val3 ;
33512 int ecode3 = 0 ;
33513 PyObject * obj0 = 0 ;
33514 PyObject * obj1 = 0 ;
33515 PyObject * obj2 = 0 ;
33516 char * kwnames[] = {
33517 (char *) "self",(char *) "x",(char *) "y", NULL
33518 };
33519
33520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33522 if (!SWIG_IsOK(res1)) {
33523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33524 }
33525 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33526 ecode2 = SWIG_AsVal_int(obj1, &val2);
33527 if (!SWIG_IsOK(ecode2)) {
33528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33529 }
33530 arg2 = static_cast< int >(val2);
33531 ecode3 = SWIG_AsVal_int(obj2, &val3);
33532 if (!SWIG_IsOK(ecode3)) {
33533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33534 }
33535 arg3 = static_cast< int >(val3);
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (bool)(arg1)->OnDrop(arg2,arg3);
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 {
33543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33544 }
33545 return resultobj;
33546 fail:
33547 return NULL;
33548 }
33549
33550
33551 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33552 PyObject *resultobj = 0;
33553 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33554 int arg2 ;
33555 int arg3 ;
33556 wxDragResult arg4 ;
33557 wxDragResult result;
33558 void *argp1 = 0 ;
33559 int res1 = 0 ;
33560 int val2 ;
33561 int ecode2 = 0 ;
33562 int val3 ;
33563 int ecode3 = 0 ;
33564 int val4 ;
33565 int ecode4 = 0 ;
33566 PyObject * obj0 = 0 ;
33567 PyObject * obj1 = 0 ;
33568 PyObject * obj2 = 0 ;
33569 PyObject * obj3 = 0 ;
33570 char * kwnames[] = {
33571 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33572 };
33573
33574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33576 if (!SWIG_IsOK(res1)) {
33577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33578 }
33579 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33580 ecode2 = SWIG_AsVal_int(obj1, &val2);
33581 if (!SWIG_IsOK(ecode2)) {
33582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33583 }
33584 arg2 = static_cast< int >(val2);
33585 ecode3 = SWIG_AsVal_int(obj2, &val3);
33586 if (!SWIG_IsOK(ecode3)) {
33587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33588 }
33589 arg3 = static_cast< int >(val3);
33590 ecode4 = SWIG_AsVal_int(obj3, &val4);
33591 if (!SWIG_IsOK(ecode4)) {
33592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33593 }
33594 arg4 = static_cast< wxDragResult >(val4);
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 resultobj = SWIG_From_int(static_cast< int >(result));
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33609 PyObject *obj;
33610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33612 return SWIG_Py_Void();
33613 }
33614
33615 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33616 return SWIG_Python_InitShadowInstance(args);
33617 }
33618
33619 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33620 PyObject *resultobj = 0;
33621 wxPyFileDropTarget *result = 0 ;
33622
33623 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33624 {
33625 PyThreadState* __tstate = wxPyBeginAllowThreads();
33626 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33631 return resultobj;
33632 fail:
33633 return NULL;
33634 }
33635
33636
33637 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33638 PyObject *resultobj = 0;
33639 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33640 PyObject *arg2 = (PyObject *) 0 ;
33641 PyObject *arg3 = (PyObject *) 0 ;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 PyObject * obj0 = 0 ;
33645 PyObject * obj1 = 0 ;
33646 PyObject * obj2 = 0 ;
33647 char * kwnames[] = {
33648 (char *) "self",(char *) "self",(char *) "_class", NULL
33649 };
33650
33651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33653 if (!SWIG_IsOK(res1)) {
33654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33655 }
33656 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33657 arg2 = obj1;
33658 arg3 = obj2;
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 (arg1)->_setCallbackInfo(arg2,arg3);
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 resultobj = SWIG_Py_Void();
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33675 int arg2 ;
33676 int arg3 ;
33677 wxArrayString *arg4 = 0 ;
33678 bool result;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 int val2 ;
33682 int ecode2 = 0 ;
33683 int val3 ;
33684 int ecode3 = 0 ;
33685 bool temp4 = false ;
33686 PyObject * obj0 = 0 ;
33687 PyObject * obj1 = 0 ;
33688 PyObject * obj2 = 0 ;
33689 PyObject * obj3 = 0 ;
33690 char * kwnames[] = {
33691 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33692 };
33693
33694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33696 if (!SWIG_IsOK(res1)) {
33697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33698 }
33699 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33700 ecode2 = SWIG_AsVal_int(obj1, &val2);
33701 if (!SWIG_IsOK(ecode2)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33703 }
33704 arg2 = static_cast< int >(val2);
33705 ecode3 = SWIG_AsVal_int(obj2, &val3);
33706 if (!SWIG_IsOK(ecode3)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33708 }
33709 arg3 = static_cast< int >(val3);
33710 {
33711 if (! PySequence_Check(obj3)) {
33712 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33713 SWIG_fail;
33714 }
33715 arg4 = new wxArrayString;
33716 temp4 = true;
33717 int i, len=PySequence_Length(obj3);
33718 for (i=0; i<len; i++) {
33719 PyObject* item = PySequence_GetItem(obj3, i);
33720 wxString* s = wxString_in_helper(item);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 arg4->Add(*s);
33723 delete s;
33724 Py_DECREF(item);
33725 }
33726 }
33727 {
33728 PyThreadState* __tstate = wxPyBeginAllowThreads();
33729 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33730 wxPyEndAllowThreads(__tstate);
33731 if (PyErr_Occurred()) SWIG_fail;
33732 }
33733 {
33734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33735 }
33736 {
33737 if (temp4) delete arg4;
33738 }
33739 return resultobj;
33740 fail:
33741 {
33742 if (temp4) delete arg4;
33743 }
33744 return NULL;
33745 }
33746
33747
33748 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj = 0;
33750 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33751 int arg2 ;
33752 int arg3 ;
33753 wxDragResult arg4 ;
33754 wxDragResult result;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 int val2 ;
33758 int ecode2 = 0 ;
33759 int val3 ;
33760 int ecode3 = 0 ;
33761 int val4 ;
33762 int ecode4 = 0 ;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 PyObject * obj2 = 0 ;
33766 PyObject * obj3 = 0 ;
33767 char * kwnames[] = {
33768 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33769 };
33770
33771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33775 }
33776 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33777 ecode2 = SWIG_AsVal_int(obj1, &val2);
33778 if (!SWIG_IsOK(ecode2)) {
33779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33780 }
33781 arg2 = static_cast< int >(val2);
33782 ecode3 = SWIG_AsVal_int(obj2, &val3);
33783 if (!SWIG_IsOK(ecode3)) {
33784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33785 }
33786 arg3 = static_cast< int >(val3);
33787 ecode4 = SWIG_AsVal_int(obj3, &val4);
33788 if (!SWIG_IsOK(ecode4)) {
33789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33790 }
33791 arg4 = static_cast< wxDragResult >(val4);
33792 {
33793 PyThreadState* __tstate = wxPyBeginAllowThreads();
33794 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 resultobj = SWIG_From_int(static_cast< int >(result));
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj = 0;
33807 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33808 int arg2 ;
33809 int arg3 ;
33810 wxDragResult arg4 ;
33811 wxDragResult result;
33812 void *argp1 = 0 ;
33813 int res1 = 0 ;
33814 int val2 ;
33815 int ecode2 = 0 ;
33816 int val3 ;
33817 int ecode3 = 0 ;
33818 int val4 ;
33819 int ecode4 = 0 ;
33820 PyObject * obj0 = 0 ;
33821 PyObject * obj1 = 0 ;
33822 PyObject * obj2 = 0 ;
33823 PyObject * obj3 = 0 ;
33824 char * kwnames[] = {
33825 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33826 };
33827
33828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33830 if (!SWIG_IsOK(res1)) {
33831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33832 }
33833 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33834 ecode2 = SWIG_AsVal_int(obj1, &val2);
33835 if (!SWIG_IsOK(ecode2)) {
33836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33837 }
33838 arg2 = static_cast< int >(val2);
33839 ecode3 = SWIG_AsVal_int(obj2, &val3);
33840 if (!SWIG_IsOK(ecode3)) {
33841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33842 }
33843 arg3 = static_cast< int >(val3);
33844 ecode4 = SWIG_AsVal_int(obj3, &val4);
33845 if (!SWIG_IsOK(ecode4)) {
33846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33847 }
33848 arg4 = static_cast< wxDragResult >(val4);
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 resultobj = SWIG_From_int(static_cast< int >(result));
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33863 PyObject *resultobj = 0;
33864 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 PyObject *swig_obj[1] ;
33868
33869 if (!args) SWIG_fail;
33870 swig_obj[0] = args;
33871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33874 }
33875 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33876 {
33877 PyThreadState* __tstate = wxPyBeginAllowThreads();
33878 (arg1)->OnLeave();
33879 wxPyEndAllowThreads(__tstate);
33880 if (PyErr_Occurred()) SWIG_fail;
33881 }
33882 resultobj = SWIG_Py_Void();
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33890 PyObject *resultobj = 0;
33891 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33892 int arg2 ;
33893 int arg3 ;
33894 bool result;
33895 void *argp1 = 0 ;
33896 int res1 = 0 ;
33897 int val2 ;
33898 int ecode2 = 0 ;
33899 int val3 ;
33900 int ecode3 = 0 ;
33901 PyObject * obj0 = 0 ;
33902 PyObject * obj1 = 0 ;
33903 PyObject * obj2 = 0 ;
33904 char * kwnames[] = {
33905 (char *) "self",(char *) "x",(char *) "y", NULL
33906 };
33907
33908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33912 }
33913 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33914 ecode2 = SWIG_AsVal_int(obj1, &val2);
33915 if (!SWIG_IsOK(ecode2)) {
33916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33917 }
33918 arg2 = static_cast< int >(val2);
33919 ecode3 = SWIG_AsVal_int(obj2, &val3);
33920 if (!SWIG_IsOK(ecode3)) {
33921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33922 }
33923 arg3 = static_cast< int >(val3);
33924 {
33925 PyThreadState* __tstate = wxPyBeginAllowThreads();
33926 result = (bool)(arg1)->OnDrop(arg2,arg3);
33927 wxPyEndAllowThreads(__tstate);
33928 if (PyErr_Occurred()) SWIG_fail;
33929 }
33930 {
33931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33932 }
33933 return resultobj;
33934 fail:
33935 return NULL;
33936 }
33937
33938
33939 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33940 PyObject *resultobj = 0;
33941 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33942 int arg2 ;
33943 int arg3 ;
33944 wxDragResult arg4 ;
33945 wxDragResult result;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 int val2 ;
33949 int ecode2 = 0 ;
33950 int val3 ;
33951 int ecode3 = 0 ;
33952 int val4 ;
33953 int ecode4 = 0 ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 PyObject * obj2 = 0 ;
33957 PyObject * obj3 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33966 }
33967 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33968 ecode2 = SWIG_AsVal_int(obj1, &val2);
33969 if (!SWIG_IsOK(ecode2)) {
33970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33971 }
33972 arg2 = static_cast< int >(val2);
33973 ecode3 = SWIG_AsVal_int(obj2, &val3);
33974 if (!SWIG_IsOK(ecode3)) {
33975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33976 }
33977 arg3 = static_cast< int >(val3);
33978 ecode4 = SWIG_AsVal_int(obj3, &val4);
33979 if (!SWIG_IsOK(ecode4)) {
33980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33981 }
33982 arg4 = static_cast< wxDragResult >(val4);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_From_int(static_cast< int >(result));
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33997 PyObject *obj;
33998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33999 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34000 return SWIG_Py_Void();
34001 }
34002
34003 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34004 return SWIG_Python_InitShadowInstance(args);
34005 }
34006
34007 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34008 PyObject *resultobj = 0;
34009 wxClipboard *result = 0 ;
34010
34011 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 result = (wxClipboard *)new wxClipboard();
34015 wxPyEndAllowThreads(__tstate);
34016 if (PyErr_Occurred()) SWIG_fail;
34017 }
34018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34026 PyObject *resultobj = 0;
34027 wxClipboard *arg1 = (wxClipboard *) 0 ;
34028 void *argp1 = 0 ;
34029 int res1 = 0 ;
34030 PyObject *swig_obj[1] ;
34031
34032 if (!args) SWIG_fail;
34033 swig_obj[0] = args;
34034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34035 if (!SWIG_IsOK(res1)) {
34036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34037 }
34038 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 delete arg1;
34042
34043 wxPyEndAllowThreads(__tstate);
34044 if (PyErr_Occurred()) SWIG_fail;
34045 }
34046 resultobj = SWIG_Py_Void();
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *resultobj = 0;
34055 wxClipboard *arg1 = (wxClipboard *) 0 ;
34056 bool result;
34057 void *argp1 = 0 ;
34058 int res1 = 0 ;
34059 PyObject *swig_obj[1] ;
34060
34061 if (!args) SWIG_fail;
34062 swig_obj[0] = args;
34063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34064 if (!SWIG_IsOK(res1)) {
34065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34066 }
34067 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 result = (bool)(arg1)->Open();
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 {
34075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34076 }
34077 return resultobj;
34078 fail:
34079 return NULL;
34080 }
34081
34082
34083 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34084 PyObject *resultobj = 0;
34085 wxClipboard *arg1 = (wxClipboard *) 0 ;
34086 void *argp1 = 0 ;
34087 int res1 = 0 ;
34088 PyObject *swig_obj[1] ;
34089
34090 if (!args) SWIG_fail;
34091 swig_obj[0] = args;
34092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34093 if (!SWIG_IsOK(res1)) {
34094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34095 }
34096 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34097 {
34098 PyThreadState* __tstate = wxPyBeginAllowThreads();
34099 (arg1)->Close();
34100 wxPyEndAllowThreads(__tstate);
34101 if (PyErr_Occurred()) SWIG_fail;
34102 }
34103 resultobj = SWIG_Py_Void();
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111 PyObject *resultobj = 0;
34112 wxClipboard *arg1 = (wxClipboard *) 0 ;
34113 bool result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 PyObject *swig_obj[1] ;
34117
34118 if (!args) SWIG_fail;
34119 swig_obj[0] = args;
34120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34123 }
34124 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 {
34132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34133 }
34134 return resultobj;
34135 fail:
34136 return NULL;
34137 }
34138
34139
34140 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34141 PyObject *resultobj = 0;
34142 wxClipboard *arg1 = (wxClipboard *) 0 ;
34143 wxDataObject *arg2 = (wxDataObject *) 0 ;
34144 bool result;
34145 void *argp1 = 0 ;
34146 int res1 = 0 ;
34147 int res2 = 0 ;
34148 PyObject * obj0 = 0 ;
34149 PyObject * obj1 = 0 ;
34150 char * kwnames[] = {
34151 (char *) "self",(char *) "data", NULL
34152 };
34153
34154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34156 if (!SWIG_IsOK(res1)) {
34157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34158 }
34159 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34160 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34161 if (!SWIG_IsOK(res2)) {
34162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34163 }
34164 {
34165 PyThreadState* __tstate = wxPyBeginAllowThreads();
34166 result = (bool)(arg1)->AddData(arg2);
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 {
34171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34172 }
34173 return resultobj;
34174 fail:
34175 return NULL;
34176 }
34177
34178
34179 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34180 PyObject *resultobj = 0;
34181 wxClipboard *arg1 = (wxClipboard *) 0 ;
34182 wxDataObject *arg2 = (wxDataObject *) 0 ;
34183 bool result;
34184 void *argp1 = 0 ;
34185 int res1 = 0 ;
34186 int res2 = 0 ;
34187 PyObject * obj0 = 0 ;
34188 PyObject * obj1 = 0 ;
34189 char * kwnames[] = {
34190 (char *) "self",(char *) "data", NULL
34191 };
34192
34193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34195 if (!SWIG_IsOK(res1)) {
34196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34197 }
34198 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34199 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34200 if (!SWIG_IsOK(res2)) {
34201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34202 }
34203 {
34204 PyThreadState* __tstate = wxPyBeginAllowThreads();
34205 result = (bool)(arg1)->SetData(arg2);
34206 wxPyEndAllowThreads(__tstate);
34207 if (PyErr_Occurred()) SWIG_fail;
34208 }
34209 {
34210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34211 }
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34219 PyObject *resultobj = 0;
34220 wxClipboard *arg1 = (wxClipboard *) 0 ;
34221 wxDataFormat *arg2 = 0 ;
34222 bool result;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 void *argp2 = 0 ;
34226 int res2 = 0 ;
34227 PyObject * obj0 = 0 ;
34228 PyObject * obj1 = 0 ;
34229 char * kwnames[] = {
34230 (char *) "self",(char *) "format", NULL
34231 };
34232
34233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34237 }
34238 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34240 if (!SWIG_IsOK(res2)) {
34241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34242 }
34243 if (!argp2) {
34244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34245 }
34246 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 {
34254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34255 }
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34263 PyObject *resultobj = 0;
34264 wxClipboard *arg1 = (wxClipboard *) 0 ;
34265 wxDataObject *arg2 = 0 ;
34266 bool result;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 void *argp2 = 0 ;
34270 int res2 = 0 ;
34271 PyObject * obj0 = 0 ;
34272 PyObject * obj1 = 0 ;
34273 char * kwnames[] = {
34274 (char *) "self",(char *) "data", NULL
34275 };
34276
34277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34279 if (!SWIG_IsOK(res1)) {
34280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34281 }
34282 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34284 if (!SWIG_IsOK(res2)) {
34285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34286 }
34287 if (!argp2) {
34288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34289 }
34290 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34291 {
34292 PyThreadState* __tstate = wxPyBeginAllowThreads();
34293 result = (bool)(arg1)->GetData(*arg2);
34294 wxPyEndAllowThreads(__tstate);
34295 if (PyErr_Occurred()) SWIG_fail;
34296 }
34297 {
34298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34299 }
34300 return resultobj;
34301 fail:
34302 return NULL;
34303 }
34304
34305
34306 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34307 PyObject *resultobj = 0;
34308 wxClipboard *arg1 = (wxClipboard *) 0 ;
34309 void *argp1 = 0 ;
34310 int res1 = 0 ;
34311 PyObject *swig_obj[1] ;
34312
34313 if (!args) SWIG_fail;
34314 swig_obj[0] = args;
34315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34316 if (!SWIG_IsOK(res1)) {
34317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34318 }
34319 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34320 {
34321 PyThreadState* __tstate = wxPyBeginAllowThreads();
34322 (arg1)->Clear();
34323 wxPyEndAllowThreads(__tstate);
34324 if (PyErr_Occurred()) SWIG_fail;
34325 }
34326 resultobj = SWIG_Py_Void();
34327 return resultobj;
34328 fail:
34329 return NULL;
34330 }
34331
34332
34333 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34334 PyObject *resultobj = 0;
34335 wxClipboard *arg1 = (wxClipboard *) 0 ;
34336 bool result;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 PyObject *swig_obj[1] ;
34340
34341 if (!args) SWIG_fail;
34342 swig_obj[0] = args;
34343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34346 }
34347 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 result = (bool)(arg1)->Flush();
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 {
34355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34356 }
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj = 0;
34365 wxClipboard *arg1 = (wxClipboard *) 0 ;
34366 bool arg2 = (bool) true ;
34367 void *argp1 = 0 ;
34368 int res1 = 0 ;
34369 bool val2 ;
34370 int ecode2 = 0 ;
34371 PyObject * obj0 = 0 ;
34372 PyObject * obj1 = 0 ;
34373 char * kwnames[] = {
34374 (char *) "self",(char *) "primary", NULL
34375 };
34376
34377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34379 if (!SWIG_IsOK(res1)) {
34380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34381 }
34382 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34383 if (obj1) {
34384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34385 if (!SWIG_IsOK(ecode2)) {
34386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34387 }
34388 arg2 = static_cast< bool >(val2);
34389 }
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 (arg1)->UsePrimarySelection(arg2);
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_Py_Void();
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxClipboard *result = 0 ;
34406
34407 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34408 {
34409 PyThreadState* __tstate = wxPyBeginAllowThreads();
34410 result = (wxClipboard *)wxClipboard::Get();
34411 wxPyEndAllowThreads(__tstate);
34412 if (PyErr_Occurred()) SWIG_fail;
34413 }
34414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34415 return resultobj;
34416 fail:
34417 return NULL;
34418 }
34419
34420
34421 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34422 PyObject *obj;
34423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34424 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34425 return SWIG_Py_Void();
34426 }
34427
34428 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34429 return SWIG_Python_InitShadowInstance(args);
34430 }
34431
34432 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34433 PyObject *resultobj = 0;
34434 wxClipboard *arg1 = (wxClipboard *) NULL ;
34435 wxClipboardLocker *result = 0 ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 PyObject * obj0 = 0 ;
34439 char * kwnames[] = {
34440 (char *) "clipboard", NULL
34441 };
34442
34443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34444 if (obj0) {
34445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34446 if (!SWIG_IsOK(res1)) {
34447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34448 }
34449 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34450 }
34451 {
34452 PyThreadState* __tstate = wxPyBeginAllowThreads();
34453 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34454 wxPyEndAllowThreads(__tstate);
34455 if (PyErr_Occurred()) SWIG_fail;
34456 }
34457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34458 return resultobj;
34459 fail:
34460 return NULL;
34461 }
34462
34463
34464 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34465 PyObject *resultobj = 0;
34466 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 PyObject *swig_obj[1] ;
34470
34471 if (!args) SWIG_fail;
34472 swig_obj[0] = args;
34473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34476 }
34477 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 delete arg1;
34481
34482 wxPyEndAllowThreads(__tstate);
34483 if (PyErr_Occurred()) SWIG_fail;
34484 }
34485 resultobj = SWIG_Py_Void();
34486 return resultobj;
34487 fail:
34488 return NULL;
34489 }
34490
34491
34492 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34493 PyObject *resultobj = 0;
34494 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34495 bool result;
34496 void *argp1 = 0 ;
34497 int res1 = 0 ;
34498 PyObject *swig_obj[1] ;
34499
34500 if (!args) SWIG_fail;
34501 swig_obj[0] = args;
34502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34503 if (!SWIG_IsOK(res1)) {
34504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34505 }
34506 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 result = (bool)wxClipboardLocker___nonzero__(arg1);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 {
34514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34515 }
34516 return resultobj;
34517 fail:
34518 return NULL;
34519 }
34520
34521
34522 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34523 PyObject *obj;
34524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34525 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34526 return SWIG_Py_Void();
34527 }
34528
34529 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 return SWIG_Python_InitShadowInstance(args);
34531 }
34532
34533 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj = 0;
34535 int arg1 = (int) 0 ;
34536 int arg2 = (int) 0 ;
34537 int arg3 = (int) 0 ;
34538 int arg4 = (int) 0 ;
34539 wxVideoMode *result = 0 ;
34540 int val1 ;
34541 int ecode1 = 0 ;
34542 int val2 ;
34543 int ecode2 = 0 ;
34544 int val3 ;
34545 int ecode3 = 0 ;
34546 int val4 ;
34547 int ecode4 = 0 ;
34548 PyObject * obj0 = 0 ;
34549 PyObject * obj1 = 0 ;
34550 PyObject * obj2 = 0 ;
34551 PyObject * obj3 = 0 ;
34552 char * kwnames[] = {
34553 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34554 };
34555
34556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34557 if (obj0) {
34558 ecode1 = SWIG_AsVal_int(obj0, &val1);
34559 if (!SWIG_IsOK(ecode1)) {
34560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34561 }
34562 arg1 = static_cast< int >(val1);
34563 }
34564 if (obj1) {
34565 ecode2 = SWIG_AsVal_int(obj1, &val2);
34566 if (!SWIG_IsOK(ecode2)) {
34567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34568 }
34569 arg2 = static_cast< int >(val2);
34570 }
34571 if (obj2) {
34572 ecode3 = SWIG_AsVal_int(obj2, &val3);
34573 if (!SWIG_IsOK(ecode3)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34575 }
34576 arg3 = static_cast< int >(val3);
34577 }
34578 if (obj3) {
34579 ecode4 = SWIG_AsVal_int(obj3, &val4);
34580 if (!SWIG_IsOK(ecode4)) {
34581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34582 }
34583 arg4 = static_cast< int >(val4);
34584 }
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 PyObject *resultobj = 0;
34600 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 PyObject *swig_obj[1] ;
34604
34605 if (!args) SWIG_fail;
34606 swig_obj[0] = args;
34607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34610 }
34611 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 delete arg1;
34615
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 resultobj = SWIG_Py_Void();
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj = 0;
34628 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34629 wxVideoMode *arg2 = 0 ;
34630 bool result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 void *argp2 = 0 ;
34634 int res2 = 0 ;
34635 PyObject * obj0 = 0 ;
34636 PyObject * obj1 = 0 ;
34637 char * kwnames[] = {
34638 (char *) "self",(char *) "other", NULL
34639 };
34640
34641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34643 if (!SWIG_IsOK(res1)) {
34644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34645 }
34646 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34647 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34648 if (!SWIG_IsOK(res2)) {
34649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34650 }
34651 if (!argp2) {
34652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34653 }
34654 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34655 {
34656 PyThreadState* __tstate = wxPyBeginAllowThreads();
34657 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34658 wxPyEndAllowThreads(__tstate);
34659 if (PyErr_Occurred()) SWIG_fail;
34660 }
34661 {
34662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34663 }
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34671 PyObject *resultobj = 0;
34672 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34673 int result;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 PyObject *swig_obj[1] ;
34677
34678 if (!args) SWIG_fail;
34679 swig_obj[0] = args;
34680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34681 if (!SWIG_IsOK(res1)) {
34682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34683 }
34684 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 resultobj = SWIG_From_int(static_cast< int >(result));
34692 return resultobj;
34693 fail:
34694 return NULL;
34695 }
34696
34697
34698 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34699 PyObject *resultobj = 0;
34700 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34701 int result;
34702 void *argp1 = 0 ;
34703 int res1 = 0 ;
34704 PyObject *swig_obj[1] ;
34705
34706 if (!args) SWIG_fail;
34707 swig_obj[0] = args;
34708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34709 if (!SWIG_IsOK(res1)) {
34710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34711 }
34712 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 resultobj = SWIG_From_int(static_cast< int >(result));
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34727 PyObject *resultobj = 0;
34728 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34729 int result;
34730 void *argp1 = 0 ;
34731 int res1 = 0 ;
34732 PyObject *swig_obj[1] ;
34733
34734 if (!args) SWIG_fail;
34735 swig_obj[0] = args;
34736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34737 if (!SWIG_IsOK(res1)) {
34738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34739 }
34740 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34741 {
34742 PyThreadState* __tstate = wxPyBeginAllowThreads();
34743 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 resultobj = SWIG_From_int(static_cast< int >(result));
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34755 PyObject *resultobj = 0;
34756 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34757 bool result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 PyObject *swig_obj[1] ;
34761
34762 if (!args) SWIG_fail;
34763 swig_obj[0] = args;
34764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34767 }
34768 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34785 PyObject *resultobj = 0;
34786 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34787 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34788 bool result;
34789 void *argp1 = 0 ;
34790 int res1 = 0 ;
34791 void *argp2 = 0 ;
34792 int res2 = 0 ;
34793 PyObject * obj0 = 0 ;
34794 PyObject * obj1 = 0 ;
34795 char * kwnames[] = {
34796 (char *) "self",(char *) "other", NULL
34797 };
34798
34799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34803 }
34804 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34806 if (!SWIG_IsOK(res2)) {
34807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34808 }
34809 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 {
34817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34818 }
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj = 0;
34827 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34828 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34829 bool result;
34830 void *argp1 = 0 ;
34831 int res1 = 0 ;
34832 void *argp2 = 0 ;
34833 int res2 = 0 ;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 char * kwnames[] = {
34837 (char *) "self",(char *) "other", NULL
34838 };
34839
34840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34842 if (!SWIG_IsOK(res1)) {
34843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34844 }
34845 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34846 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34847 if (!SWIG_IsOK(res2)) {
34848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34849 }
34850 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34851 {
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 {
34858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34869 int arg2 ;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 int val2 ;
34873 int ecode2 = 0 ;
34874 PyObject *swig_obj[2] ;
34875
34876 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34878 if (!SWIG_IsOK(res1)) {
34879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34880 }
34881 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34882 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34883 if (!SWIG_IsOK(ecode2)) {
34884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34885 }
34886 arg2 = static_cast< int >(val2);
34887 if (arg1) (arg1)->w = arg2;
34888
34889 resultobj = SWIG_Py_Void();
34890 return resultobj;
34891 fail:
34892 return NULL;
34893 }
34894
34895
34896 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34897 PyObject *resultobj = 0;
34898 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34899 int result;
34900 void *argp1 = 0 ;
34901 int res1 = 0 ;
34902 PyObject *swig_obj[1] ;
34903
34904 if (!args) SWIG_fail;
34905 swig_obj[0] = args;
34906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34907 if (!SWIG_IsOK(res1)) {
34908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34909 }
34910 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34911 result = (int) ((arg1)->w);
34912 resultobj = SWIG_From_int(static_cast< int >(result));
34913 return resultobj;
34914 fail:
34915 return NULL;
34916 }
34917
34918
34919 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34920 PyObject *resultobj = 0;
34921 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34922 int arg2 ;
34923 void *argp1 = 0 ;
34924 int res1 = 0 ;
34925 int val2 ;
34926 int ecode2 = 0 ;
34927 PyObject *swig_obj[2] ;
34928
34929 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34931 if (!SWIG_IsOK(res1)) {
34932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34933 }
34934 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34935 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34936 if (!SWIG_IsOK(ecode2)) {
34937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34938 }
34939 arg2 = static_cast< int >(val2);
34940 if (arg1) (arg1)->h = arg2;
34941
34942 resultobj = SWIG_Py_Void();
34943 return resultobj;
34944 fail:
34945 return NULL;
34946 }
34947
34948
34949 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34950 PyObject *resultobj = 0;
34951 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34952 int result;
34953 void *argp1 = 0 ;
34954 int res1 = 0 ;
34955 PyObject *swig_obj[1] ;
34956
34957 if (!args) SWIG_fail;
34958 swig_obj[0] = args;
34959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34960 if (!SWIG_IsOK(res1)) {
34961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34962 }
34963 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34964 result = (int) ((arg1)->h);
34965 resultobj = SWIG_From_int(static_cast< int >(result));
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34973 PyObject *resultobj = 0;
34974 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34975 int arg2 ;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 int val2 ;
34979 int ecode2 = 0 ;
34980 PyObject *swig_obj[2] ;
34981
34982 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34984 if (!SWIG_IsOK(res1)) {
34985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34986 }
34987 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34988 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34989 if (!SWIG_IsOK(ecode2)) {
34990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34991 }
34992 arg2 = static_cast< int >(val2);
34993 if (arg1) (arg1)->bpp = arg2;
34994
34995 resultobj = SWIG_Py_Void();
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35003 PyObject *resultobj = 0;
35004 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35005 int result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 PyObject *swig_obj[1] ;
35009
35010 if (!args) SWIG_fail;
35011 swig_obj[0] = args;
35012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35015 }
35016 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35017 result = (int) ((arg1)->bpp);
35018 resultobj = SWIG_From_int(static_cast< int >(result));
35019 return resultobj;
35020 fail:
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35026 PyObject *resultobj = 0;
35027 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35028 int arg2 ;
35029 void *argp1 = 0 ;
35030 int res1 = 0 ;
35031 int val2 ;
35032 int ecode2 = 0 ;
35033 PyObject *swig_obj[2] ;
35034
35035 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35037 if (!SWIG_IsOK(res1)) {
35038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35039 }
35040 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35041 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35042 if (!SWIG_IsOK(ecode2)) {
35043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35044 }
35045 arg2 = static_cast< int >(val2);
35046 if (arg1) (arg1)->refresh = arg2;
35047
35048 resultobj = SWIG_Py_Void();
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 PyObject *resultobj = 0;
35057 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35058 int result;
35059 void *argp1 = 0 ;
35060 int res1 = 0 ;
35061 PyObject *swig_obj[1] ;
35062
35063 if (!args) SWIG_fail;
35064 swig_obj[0] = args;
35065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35066 if (!SWIG_IsOK(res1)) {
35067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35068 }
35069 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35070 result = (int) ((arg1)->refresh);
35071 resultobj = SWIG_From_int(static_cast< int >(result));
35072 return resultobj;
35073 fail:
35074 return NULL;
35075 }
35076
35077
35078 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35079 PyObject *obj;
35080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35081 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35082 return SWIG_Py_Void();
35083 }
35084
35085 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 return SWIG_Python_InitShadowInstance(args);
35087 }
35088
35089 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35090 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35091 return 1;
35092 }
35093
35094
35095 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35096 PyObject *pyobj = 0;
35097
35098 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35099 return pyobj;
35100 }
35101
35102
35103 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35104 PyObject *resultobj = 0;
35105 size_t arg1 = (size_t) 0 ;
35106 wxDisplay *result = 0 ;
35107 size_t val1 ;
35108 int ecode1 = 0 ;
35109 PyObject * obj0 = 0 ;
35110 char * kwnames[] = {
35111 (char *) "index", NULL
35112 };
35113
35114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35115 if (obj0) {
35116 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35117 if (!SWIG_IsOK(ecode1)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35119 }
35120 arg1 = static_cast< size_t >(val1);
35121 }
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 result = (wxDisplay *)new wxDisplay(arg1);
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxDisplay *arg1 = (wxDisplay *) 0 ;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 PyObject *swig_obj[1] ;
35141
35142 if (!args) SWIG_fail;
35143 swig_obj[0] = args;
35144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35147 }
35148 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 delete arg1;
35152
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_Py_Void();
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35164 PyObject *resultobj = 0;
35165 size_t result;
35166
35167 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35168 {
35169 PyThreadState* __tstate = wxPyBeginAllowThreads();
35170 result = (size_t)wxDisplay::GetCount();
35171 wxPyEndAllowThreads(__tstate);
35172 if (PyErr_Occurred()) SWIG_fail;
35173 }
35174 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35175 return resultobj;
35176 fail:
35177 return NULL;
35178 }
35179
35180
35181 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35182 PyObject *resultobj = 0;
35183 wxPoint *arg1 = 0 ;
35184 int result;
35185 wxPoint temp1 ;
35186 PyObject * obj0 = 0 ;
35187 char * kwnames[] = {
35188 (char *) "pt", NULL
35189 };
35190
35191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35192 {
35193 arg1 = &temp1;
35194 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35195 }
35196 {
35197 PyThreadState* __tstate = wxPyBeginAllowThreads();
35198 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 resultobj = SWIG_From_int(static_cast< int >(result));
35203 return resultobj;
35204 fail:
35205 return NULL;
35206 }
35207
35208
35209 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35210 PyObject *resultobj = 0;
35211 wxWindow *arg1 = (wxWindow *) 0 ;
35212 int result;
35213 void *argp1 = 0 ;
35214 int res1 = 0 ;
35215 PyObject * obj0 = 0 ;
35216 char * kwnames[] = {
35217 (char *) "window", NULL
35218 };
35219
35220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35222 if (!SWIG_IsOK(res1)) {
35223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35224 }
35225 arg1 = reinterpret_cast< wxWindow * >(argp1);
35226 {
35227 PyThreadState* __tstate = wxPyBeginAllowThreads();
35228 result = (int)wxDisplay::GetFromWindow(arg1);
35229 wxPyEndAllowThreads(__tstate);
35230 if (PyErr_Occurred()) SWIG_fail;
35231 }
35232 resultobj = SWIG_From_int(static_cast< int >(result));
35233 return resultobj;
35234 fail:
35235 return NULL;
35236 }
35237
35238
35239 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35240 PyObject *resultobj = 0;
35241 wxDisplay *arg1 = (wxDisplay *) 0 ;
35242 bool result;
35243 void *argp1 = 0 ;
35244 int res1 = 0 ;
35245 PyObject *swig_obj[1] ;
35246
35247 if (!args) SWIG_fail;
35248 swig_obj[0] = args;
35249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35250 if (!SWIG_IsOK(res1)) {
35251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35252 }
35253 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35254 {
35255 PyThreadState* __tstate = wxPyBeginAllowThreads();
35256 result = (bool)((wxDisplay const *)arg1)->IsOk();
35257 wxPyEndAllowThreads(__tstate);
35258 if (PyErr_Occurred()) SWIG_fail;
35259 }
35260 {
35261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35262 }
35263 return resultobj;
35264 fail:
35265 return NULL;
35266 }
35267
35268
35269 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35270 PyObject *resultobj = 0;
35271 wxDisplay *arg1 = (wxDisplay *) 0 ;
35272 wxRect result;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 PyObject *swig_obj[1] ;
35276
35277 if (!args) SWIG_fail;
35278 swig_obj[0] = args;
35279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35280 if (!SWIG_IsOK(res1)) {
35281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35282 }
35283 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35284 {
35285 PyThreadState* __tstate = wxPyBeginAllowThreads();
35286 result = ((wxDisplay const *)arg1)->GetGeometry();
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35298 PyObject *resultobj = 0;
35299 wxDisplay *arg1 = (wxDisplay *) 0 ;
35300 wxRect result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 PyObject *swig_obj[1] ;
35304
35305 if (!args) SWIG_fail;
35306 swig_obj[0] = args;
35307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35310 }
35311 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = ((wxDisplay const *)arg1)->GetClientArea();
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35326 PyObject *resultobj = 0;
35327 wxDisplay *arg1 = (wxDisplay *) 0 ;
35328 wxString result;
35329 void *argp1 = 0 ;
35330 int res1 = 0 ;
35331 PyObject *swig_obj[1] ;
35332
35333 if (!args) SWIG_fail;
35334 swig_obj[0] = args;
35335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35336 if (!SWIG_IsOK(res1)) {
35337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35338 }
35339 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = ((wxDisplay const *)arg1)->GetName();
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 {
35347 #if wxUSE_UNICODE
35348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35349 #else
35350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35351 #endif
35352 }
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35360 PyObject *resultobj = 0;
35361 wxDisplay *arg1 = (wxDisplay *) 0 ;
35362 bool result;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 PyObject *swig_obj[1] ;
35366
35367 if (!args) SWIG_fail;
35368 swig_obj[0] = args;
35369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35372 }
35373 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 {
35381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35382 }
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35390 PyObject *resultobj = 0;
35391 wxDisplay *arg1 = (wxDisplay *) 0 ;
35392 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35393 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35394 PyObject *result = 0 ;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 void *argp2 = 0 ;
35398 int res2 = 0 ;
35399 PyObject * obj0 = 0 ;
35400 PyObject * obj1 = 0 ;
35401 char * kwnames[] = {
35402 (char *) "self",(char *) "mode", NULL
35403 };
35404
35405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35407 if (!SWIG_IsOK(res1)) {
35408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35409 }
35410 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35411 if (obj1) {
35412 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35413 if (!SWIG_IsOK(res2)) {
35414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35415 }
35416 if (!argp2) {
35417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35418 }
35419 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35420 }
35421 {
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = result;
35428 return resultobj;
35429 fail:
35430 return NULL;
35431 }
35432
35433
35434 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35435 PyObject *resultobj = 0;
35436 wxDisplay *arg1 = (wxDisplay *) 0 ;
35437 wxVideoMode result;
35438 void *argp1 = 0 ;
35439 int res1 = 0 ;
35440 PyObject *swig_obj[1] ;
35441
35442 if (!args) SWIG_fail;
35443 swig_obj[0] = args;
35444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35445 if (!SWIG_IsOK(res1)) {
35446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35447 }
35448 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35449 {
35450 PyThreadState* __tstate = wxPyBeginAllowThreads();
35451 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35452 wxPyEndAllowThreads(__tstate);
35453 if (PyErr_Occurred()) SWIG_fail;
35454 }
35455 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35456 return resultobj;
35457 fail:
35458 return NULL;
35459 }
35460
35461
35462 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35463 PyObject *resultobj = 0;
35464 wxDisplay *arg1 = (wxDisplay *) 0 ;
35465 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35466 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35467 bool result;
35468 void *argp1 = 0 ;
35469 int res1 = 0 ;
35470 void *argp2 = 0 ;
35471 int res2 = 0 ;
35472 PyObject * obj0 = 0 ;
35473 PyObject * obj1 = 0 ;
35474 char * kwnames[] = {
35475 (char *) "self",(char *) "mode", NULL
35476 };
35477
35478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35482 }
35483 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35484 if (obj1) {
35485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35486 if (!SWIG_IsOK(res2)) {
35487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35488 }
35489 if (!argp2) {
35490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35491 }
35492 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35493 }
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 {
35501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35502 }
35503 return resultobj;
35504 fail:
35505 return NULL;
35506 }
35507
35508
35509 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35510 PyObject *resultobj = 0;
35511 wxDisplay *arg1 = (wxDisplay *) 0 ;
35512 void *argp1 = 0 ;
35513 int res1 = 0 ;
35514 PyObject *swig_obj[1] ;
35515
35516 if (!args) SWIG_fail;
35517 swig_obj[0] = args;
35518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35519 if (!SWIG_IsOK(res1)) {
35520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35521 }
35522 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35523 {
35524 PyThreadState* __tstate = wxPyBeginAllowThreads();
35525 wxDisplay_ResetMode(arg1);
35526 wxPyEndAllowThreads(__tstate);
35527 if (PyErr_Occurred()) SWIG_fail;
35528 }
35529 resultobj = SWIG_Py_Void();
35530 return resultobj;
35531 fail:
35532 return NULL;
35533 }
35534
35535
35536 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35537 PyObject *obj;
35538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35539 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35540 return SWIG_Py_Void();
35541 }
35542
35543 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35544 return SWIG_Python_InitShadowInstance(args);
35545 }
35546
35547 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35548 PyObject *resultobj = 0;
35549 wxStandardPaths *result = 0 ;
35550
35551 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 result = (wxStandardPaths *)wxStandardPaths_Get();
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35566 PyObject *resultobj = 0;
35567 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35568 wxString result;
35569 void *argp1 = 0 ;
35570 int res1 = 0 ;
35571 PyObject *swig_obj[1] ;
35572
35573 if (!args) SWIG_fail;
35574 swig_obj[0] = args;
35575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 #if wxUSE_UNICODE
35588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35589 #else
35590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35591 #endif
35592 }
35593 return resultobj;
35594 fail:
35595 return NULL;
35596 }
35597
35598
35599 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35600 PyObject *resultobj = 0;
35601 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35602 wxString result;
35603 void *argp1 = 0 ;
35604 int res1 = 0 ;
35605 PyObject *swig_obj[1] ;
35606
35607 if (!args) SWIG_fail;
35608 swig_obj[0] = args;
35609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35610 if (!SWIG_IsOK(res1)) {
35611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35612 }
35613 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 #if wxUSE_UNICODE
35622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35623 #else
35624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35625 #endif
35626 }
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35634 PyObject *resultobj = 0;
35635 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35636 wxString result;
35637 void *argp1 = 0 ;
35638 int res1 = 0 ;
35639 PyObject *swig_obj[1] ;
35640
35641 if (!args) SWIG_fail;
35642 swig_obj[0] = args;
35643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35646 }
35647 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 {
35655 #if wxUSE_UNICODE
35656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35657 #else
35658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35659 #endif
35660 }
35661 return resultobj;
35662 fail:
35663 return NULL;
35664 }
35665
35666
35667 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35668 PyObject *resultobj = 0;
35669 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35670 wxString result;
35671 void *argp1 = 0 ;
35672 int res1 = 0 ;
35673 PyObject *swig_obj[1] ;
35674
35675 if (!args) SWIG_fail;
35676 swig_obj[0] = args;
35677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35678 if (!SWIG_IsOK(res1)) {
35679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35680 }
35681 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 #if wxUSE_UNICODE
35690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35691 #else
35692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35693 #endif
35694 }
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35702 PyObject *resultobj = 0;
35703 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35704 wxString result;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 PyObject *swig_obj[1] ;
35708
35709 if (!args) SWIG_fail;
35710 swig_obj[0] = args;
35711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35712 if (!SWIG_IsOK(res1)) {
35713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35714 }
35715 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35716 {
35717 PyThreadState* __tstate = wxPyBeginAllowThreads();
35718 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 {
35723 #if wxUSE_UNICODE
35724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35725 #else
35726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35727 #endif
35728 }
35729 return resultobj;
35730 fail:
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35736 PyObject *resultobj = 0;
35737 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35738 wxString result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 PyObject *swig_obj[1] ;
35742
35743 if (!args) SWIG_fail;
35744 swig_obj[0] = args;
35745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35746 if (!SWIG_IsOK(res1)) {
35747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35748 }
35749 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 {
35757 #if wxUSE_UNICODE
35758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35759 #else
35760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35761 #endif
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35772 wxString result;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35782 }
35783 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 #if wxUSE_UNICODE
35792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35793 #else
35794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35795 #endif
35796 }
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35804 PyObject *resultobj = 0;
35805 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35806 wxString result;
35807 void *argp1 = 0 ;
35808 int res1 = 0 ;
35809 PyObject *swig_obj[1] ;
35810
35811 if (!args) SWIG_fail;
35812 swig_obj[0] = args;
35813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35814 if (!SWIG_IsOK(res1)) {
35815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35816 }
35817 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35818 {
35819 PyThreadState* __tstate = wxPyBeginAllowThreads();
35820 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35821 wxPyEndAllowThreads(__tstate);
35822 if (PyErr_Occurred()) SWIG_fail;
35823 }
35824 {
35825 #if wxUSE_UNICODE
35826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35827 #else
35828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35829 #endif
35830 }
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj = 0;
35839 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35840 wxString *arg2 = 0 ;
35841 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35842 wxString result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 bool temp2 = false ;
35846 int val3 ;
35847 int ecode3 = 0 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 PyObject * obj2 = 0 ;
35851 char * kwnames[] = {
35852 (char *) "self",(char *) "lang",(char *) "category", NULL
35853 };
35854
35855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35861 {
35862 arg2 = wxString_in_helper(obj1);
35863 if (arg2 == NULL) SWIG_fail;
35864 temp2 = true;
35865 }
35866 if (obj2) {
35867 ecode3 = SWIG_AsVal_int(obj2, &val3);
35868 if (!SWIG_IsOK(ecode3)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35870 }
35871 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35872 }
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 #if wxUSE_UNICODE
35881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35882 #else
35883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35884 #endif
35885 }
35886 {
35887 if (temp2)
35888 delete arg2;
35889 }
35890 return resultobj;
35891 fail:
35892 {
35893 if (temp2)
35894 delete arg2;
35895 }
35896 return NULL;
35897 }
35898
35899
35900 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35901 PyObject *resultobj = 0;
35902 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35903 wxString result;
35904 void *argp1 = 0 ;
35905 int res1 = 0 ;
35906 PyObject *swig_obj[1] ;
35907
35908 if (!args) SWIG_fail;
35909 swig_obj[0] = args;
35910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35911 if (!SWIG_IsOK(res1)) {
35912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35913 }
35914 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35915 {
35916 PyThreadState* __tstate = wxPyBeginAllowThreads();
35917 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35918 wxPyEndAllowThreads(__tstate);
35919 if (PyErr_Occurred()) SWIG_fail;
35920 }
35921 {
35922 #if wxUSE_UNICODE
35923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35924 #else
35925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35926 #endif
35927 }
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35935 PyObject *resultobj = 0;
35936 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35937 wxString *arg2 = 0 ;
35938 void *argp1 = 0 ;
35939 int res1 = 0 ;
35940 bool temp2 = false ;
35941 PyObject * obj0 = 0 ;
35942 PyObject * obj1 = 0 ;
35943 char * kwnames[] = {
35944 (char *) "self",(char *) "prefix", NULL
35945 };
35946
35947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35949 if (!SWIG_IsOK(res1)) {
35950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35951 }
35952 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35953 {
35954 arg2 = wxString_in_helper(obj1);
35955 if (arg2 == NULL) SWIG_fail;
35956 temp2 = true;
35957 }
35958 {
35959 PyThreadState* __tstate = wxPyBeginAllowThreads();
35960 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 resultobj = SWIG_Py_Void();
35965 {
35966 if (temp2)
35967 delete arg2;
35968 }
35969 return resultobj;
35970 fail:
35971 {
35972 if (temp2)
35973 delete arg2;
35974 }
35975 return NULL;
35976 }
35977
35978
35979 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35980 PyObject *resultobj = 0;
35981 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35982 wxString result;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 PyObject *swig_obj[1] ;
35986
35987 if (!args) SWIG_fail;
35988 swig_obj[0] = args;
35989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35992 }
35993 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35994 {
35995 PyThreadState* __tstate = wxPyBeginAllowThreads();
35996 result = wxStandardPaths_GetInstallPrefix(arg1);
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 {
36001 #if wxUSE_UNICODE
36002 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36003 #else
36004 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36005 #endif
36006 }
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36014 PyObject *obj;
36015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36016 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36017 return SWIG_Py_Void();
36018 }
36019
36020 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36021 PyObject *resultobj = 0;
36022 wxEventType arg1 ;
36023 wxPowerEvent *result = 0 ;
36024 int val1 ;
36025 int ecode1 = 0 ;
36026 PyObject * obj0 = 0 ;
36027 char * kwnames[] = {
36028 (char *) "evtType", NULL
36029 };
36030
36031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36032 ecode1 = SWIG_AsVal_int(obj0, &val1);
36033 if (!SWIG_IsOK(ecode1)) {
36034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36035 }
36036 arg1 = static_cast< wxEventType >(val1);
36037 {
36038 PyThreadState* __tstate = wxPyBeginAllowThreads();
36039 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36040 wxPyEndAllowThreads(__tstate);
36041 if (PyErr_Occurred()) SWIG_fail;
36042 }
36043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36044 return resultobj;
36045 fail:
36046 return NULL;
36047 }
36048
36049
36050 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36051 PyObject *resultobj = 0;
36052 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36053 void *argp1 = 0 ;
36054 int res1 = 0 ;
36055 PyObject *swig_obj[1] ;
36056
36057 if (!args) SWIG_fail;
36058 swig_obj[0] = args;
36059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36062 }
36063 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 (arg1)->Veto();
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 resultobj = SWIG_Py_Void();
36071 return resultobj;
36072 fail:
36073 return NULL;
36074 }
36075
36076
36077 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36078 PyObject *resultobj = 0;
36079 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36080 bool result;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 PyObject *swig_obj[1] ;
36084
36085 if (!args) SWIG_fail;
36086 swig_obj[0] = args;
36087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36088 if (!SWIG_IsOK(res1)) {
36089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36090 }
36091 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36092 {
36093 PyThreadState* __tstate = wxPyBeginAllowThreads();
36094 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36095 wxPyEndAllowThreads(__tstate);
36096 if (PyErr_Occurred()) SWIG_fail;
36097 }
36098 {
36099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36100 }
36101 return resultobj;
36102 fail:
36103 return NULL;
36104 }
36105
36106
36107 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36108 PyObject *obj;
36109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36110 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36111 return SWIG_Py_Void();
36112 }
36113
36114 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36115 return SWIG_Python_InitShadowInstance(args);
36116 }
36117
36118 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36119 PyObject *resultobj = 0;
36120 wxPowerType result;
36121
36122 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36123 {
36124 PyThreadState* __tstate = wxPyBeginAllowThreads();
36125 result = (wxPowerType)wxGetPowerType();
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_From_int(static_cast< int >(result));
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxBatteryState result;
36139
36140 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36141 {
36142 PyThreadState* __tstate = wxPyBeginAllowThreads();
36143 result = (wxBatteryState)wxGetBatteryState();
36144 wxPyEndAllowThreads(__tstate);
36145 if (PyErr_Occurred()) SWIG_fail;
36146 }
36147 resultobj = SWIG_From_int(static_cast< int >(result));
36148 return resultobj;
36149 fail:
36150 return NULL;
36151 }
36152
36153
36154 static PyMethodDef SwigMethods[] = {
36155 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36160 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36161 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36162 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36163 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36164 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36167 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36168 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36170 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36171 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36172 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36174 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36178 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36179 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36181 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36182 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36184 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36185 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36186 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36187 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36188 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36191 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36193 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36194 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36195 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36196 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36197 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36198 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36199 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36201 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36202 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36210 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36212 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36213 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36214 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36215 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36216 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36217 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36218 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36219 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36220 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36222 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36224 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36225 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36226 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36228 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36230 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36231 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36232 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36233 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36234 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36235 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36236 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36237 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36238 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36239 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36240 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36241 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36242 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36243 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36249 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36253 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36254 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36255 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36256 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36257 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36258 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36259 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36260 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36261 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36262 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36263 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36265 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36267 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36268 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36271 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36272 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36274 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36275 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36276 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36277 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36278 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36279 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36280 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36281 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36282 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36288 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36289 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36291 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36292 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36293 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36294 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36295 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36296 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36297 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36298 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36299 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36300 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36302 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36303 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36304 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36305 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36307 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36308 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36309 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36310 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36311 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36313 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36316 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36321 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36324 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36325 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36326 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36328 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36329 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36331 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36332 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36333 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36335 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36336 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36337 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36339 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36342 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36343 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36347 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36350 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36352 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36353 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36354 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36355 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36356 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36357 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36358 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36359 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36361 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36362 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36363 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36364 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36365 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36367 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36368 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36369 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36370 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36371 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36374 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36375 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36376 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36378 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36379 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36382 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36386 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36387 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36388 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36389 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36390 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36392 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36393 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36394 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36395 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36396 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36397 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36398 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36399 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36400 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36402 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36403 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36404 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36405 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36406 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36409 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36410 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36411 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36413 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36414 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36418 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36419 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36420 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36421 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36422 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36423 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36424 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36425 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36426 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36437 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36439 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36441 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36442 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36443 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36444 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36445 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36447 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36448 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36449 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36455 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36456 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36457 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36458 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36459 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36460 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36461 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36462 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36463 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36464 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36465 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36466 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36468 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36469 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36470 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36471 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36472 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36473 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36474 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36475 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36479 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36480 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36481 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36482 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36483 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36484 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36485 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36486 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36487 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36488 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36490 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36491 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36492 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36493 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36494 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36495 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36496 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36497 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36498 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36499 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36500 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36501 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36502 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36503 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36504 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36505 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36506 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36507 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36508 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36509 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36510 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36511 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36512 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36513 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36514 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36515 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36516 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36517 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36518 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36519 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36521 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36522 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36523 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36525 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36526 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36527 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36528 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36529 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36535 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36536 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36537 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36541 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36542 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36545 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36548 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36551 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36552 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36553 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36556 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36557 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36560 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36561 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36562 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36563 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36564 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36565 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36566 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36567 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36568 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36569 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36570 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36572 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36573 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36574 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36575 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36576 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36577 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36578 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36584 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36586 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36587 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36589 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36591 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36596 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36600 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36601 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36602 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36603 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36604 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36607 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36612 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36613 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36614 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36615 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36618 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36619 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36621 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36622 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36624 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36645 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36647 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36649 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36651 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36652 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36656 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36657 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36659 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36660 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36661 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36663 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36664 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36665 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36667 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36668 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36669 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36670 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36673 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36677 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36684 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36688 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36689 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36690 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36691 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36697 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36698 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36703 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36727 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36728 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36729 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36730 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36731 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36743 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36744 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36770 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36771 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36772 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36773 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36775 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36777 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36782 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36786 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36787 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36788 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36789 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36790 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36791 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36793 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36795 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36797 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36799 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36801 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36803 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36805 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36809 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36810 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36814 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36825 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36826 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36827 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36831 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36832 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36833 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36834 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36835 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36836 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36838 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36839 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36841 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36843 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36845 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36847 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36849 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36854 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36855 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36856 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36857 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36858 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36861 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36865 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36873 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36874 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36875 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36876 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36877 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36878 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36881 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36882 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36883 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36885 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36886 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36888 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36889 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36890 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36898 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36900 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36902 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36903 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36904 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36905 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36906 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36909 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36910 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36911 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36913 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36914 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36915 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36917 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36918 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36920 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36921 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36924 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36925 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36927 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36929 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36930 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36933 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36934 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36935 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36936 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36938 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36939 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36940 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36942 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36943 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36944 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36945 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36946 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36947 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36948 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36949 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36950 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36951 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36952 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36953 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36954 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36955 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36959 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36961 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36962 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36963 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36965 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36966 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36968 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36969 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36970 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36971 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36972 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36974 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36975 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36976 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36978 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36979 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36980 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36981 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36986 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36988 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36989 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36990 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36991 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36994 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36996 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36998 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36999 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37000 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37001 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37002 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37003 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37004 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37005 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37006 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37007 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37008 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37010 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37011 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37013 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37014 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37015 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37016 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37017 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37018 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37019 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37020 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37022 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37023 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37024 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37025 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37026 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37027 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37028 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37029 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37030 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37031 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37032 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37033 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37034 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37035 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37036 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37037 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37038 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37039 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37040 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37041 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37042 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37043 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37045 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37046 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37047 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37048 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37049 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37050 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37051 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37052 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37053 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37054 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37055 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37056 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37057 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37058 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37059 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37060 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37061 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37062 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37063 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37064 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37065 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37066 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37067 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37068 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37069 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37070 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37071 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37072 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37073 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37074 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37075 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37076 { NULL, NULL, 0, NULL }
37077 };
37078
37079
37080 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37081
37082 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37083 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37084 }
37085 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37086 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37087 }
37088 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37089 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37090 }
37091 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37092 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37093 }
37094 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37095 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37096 }
37097 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37098 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37099 }
37100 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37101 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37102 }
37103 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37104 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37105 }
37106 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37107 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37108 }
37109 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37110 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37111 }
37112 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37113 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37114 }
37115 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37116 return (void *)((wxEvent *) ((wxPyEvent *) x));
37117 }
37118 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37119 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37120 }
37121 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37122 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37123 }
37124 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37125 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37126 }
37127 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37128 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37129 }
37130 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37131 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37132 }
37133 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37134 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37135 }
37136 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37137 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37138 }
37139 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37140 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37141 }
37142 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37143 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37144 }
37145 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37146 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37147 }
37148 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37150 }
37151 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37152 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37153 }
37154 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37155 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37156 }
37157 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37159 }
37160 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37161 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37162 }
37163 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37164 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37165 }
37166 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37167 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37168 }
37169 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37170 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37171 }
37172 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37173 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37174 }
37175 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37176 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37177 }
37178 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37180 }
37181 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37182 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37183 }
37184 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37185 return (void *)((wxEvent *) ((wxShowEvent *) x));
37186 }
37187 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37188 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37189 }
37190 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37192 }
37193 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37194 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37195 }
37196 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37197 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37198 }
37199 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37200 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37201 }
37202 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37203 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37204 }
37205 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37206 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37207 }
37208 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37209 return (void *)((wxConfigBase *) ((wxConfig *) x));
37210 }
37211 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37212 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37213 }
37214 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37215 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37216 }
37217 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37218 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37219 }
37220 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37221 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37222 }
37223 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37224 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37225 }
37226 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37227 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37228 }
37229 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37230 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37231 }
37232 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37233 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37234 }
37235 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37236 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37237 }
37238 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37239 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37240 }
37241 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37242 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37243 }
37244 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37245 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37246 }
37247 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37248 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37249 }
37250 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37251 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37252 }
37253 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37254 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37255 }
37256 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37257 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37258 }
37259 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37260 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37261 }
37262 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37263 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37264 }
37265 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37266 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37267 }
37268 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37269 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37270 }
37271 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37272 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37273 }
37274 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37275 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37276 }
37277 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37278 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37279 }
37280 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37281 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37282 }
37283 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37284 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37285 }
37286 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37287 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37288 }
37289 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37290 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37291 }
37292 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37293 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37294 }
37295 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37296 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37297 }
37298 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37299 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37300 }
37301 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37302 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37303 }
37304 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37305 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37306 }
37307 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37308 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37309 }
37310 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37311 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37312 }
37313 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37314 return (void *)((wxObject *) ((wxSizerItem *) x));
37315 }
37316 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37317 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37318 }
37319 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37320 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37321 }
37322 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37323 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37324 }
37325 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37326 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37327 }
37328 static void *_p_wxSizerTo_p_wxObject(void *x) {
37329 return (void *)((wxObject *) ((wxSizer *) x));
37330 }
37331 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37332 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37333 }
37334 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37335 return (void *)((wxObject *) ((wxFileHistory *) x));
37336 }
37337 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37338 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37339 }
37340 static void *_p_wxEventTo_p_wxObject(void *x) {
37341 return (void *)((wxObject *) ((wxEvent *) x));
37342 }
37343 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37344 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37345 }
37346 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37347 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37348 }
37349 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37350 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37351 }
37352 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37354 }
37355 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37356 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37357 }
37358 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37359 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37360 }
37361 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37362 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37363 }
37364 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37365 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37366 }
37367 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37368 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37369 }
37370 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37371 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37372 }
37373 static void *_p_wxControlTo_p_wxObject(void *x) {
37374 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37375 }
37376 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37377 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37378 }
37379 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37380 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37381 }
37382 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37383 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37384 }
37385 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37386 return (void *)((wxObject *) ((wxFSFile *) x));
37387 }
37388 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37389 return (void *)((wxObject *) ((wxClipboard *) x));
37390 }
37391 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37392 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37393 }
37394 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37395 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37396 }
37397 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37398 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37399 }
37400 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37401 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37402 }
37403 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37404 return (void *)((wxObject *) ((wxToolTip *) x));
37405 }
37406 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37407 return (void *)((wxObject *) ((wxMenuItem *) x));
37408 }
37409 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37410 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37411 }
37412 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37413 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37414 }
37415 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37416 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37417 }
37418 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37419 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37420 }
37421 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37422 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37423 }
37424 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37425 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37426 }
37427 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37428 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37429 }
37430 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37431 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37432 }
37433 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37434 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37435 }
37436 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37437 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37438 }
37439 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37440 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37441 }
37442 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37443 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37444 }
37445 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37446 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37447 }
37448 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37449 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37450 }
37451 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37452 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37453 }
37454 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37455 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37456 }
37457 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37458 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37459 }
37460 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37461 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37462 }
37463 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37464 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37465 }
37466 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37467 return (void *)((wxObject *) ((wxImageHandler *) x));
37468 }
37469 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37470 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37471 }
37472 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37473 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37474 }
37475 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37476 return (void *)((wxObject *) ((wxEvtHandler *) x));
37477 }
37478 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37479 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37480 }
37481 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37482 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37483 }
37484 static void *_p_wxImageTo_p_wxObject(void *x) {
37485 return (void *)((wxObject *) ((wxImage *) x));
37486 }
37487 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37488 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37489 }
37490 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37491 return (void *)((wxObject *) ((wxSystemOptions *) x));
37492 }
37493 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37494 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37495 }
37496 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37497 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37498 }
37499 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37500 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37501 }
37502 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37503 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37504 }
37505 static void *_p_wxWindowTo_p_wxObject(void *x) {
37506 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37507 }
37508 static void *_p_wxMenuTo_p_wxObject(void *x) {
37509 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37510 }
37511 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37512 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37513 }
37514 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37515 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37516 }
37517 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37518 return (void *)((wxObject *) ((wxFileSystem *) x));
37519 }
37520 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37521 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37522 }
37523 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37524 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37525 }
37526 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37527 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37528 }
37529 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37530 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37531 }
37532 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37533 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37534 }
37535 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37536 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37537 }
37538 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37539 return (void *)((wxObject *) ((wxBusyInfo *) x));
37540 }
37541 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37542 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37543 }
37544 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37545 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37546 }
37547 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37548 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37549 }
37550 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37551 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37552 }
37553 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37554 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37555 }
37556 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37557 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37558 }
37559 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37560 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37561 }
37562 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37563 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37564 }
37565 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37566 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37567 }
37568 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37569 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37570 }
37571 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37572 return (void *)((wxLog *) ((wxLogBuffer *) x));
37573 }
37574 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37575 return (void *)((wxLog *) ((wxLogStderr *) x));
37576 }
37577 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37578 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37579 }
37580 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37581 return (void *)((wxLog *) ((wxLogWindow *) x));
37582 }
37583 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37584 return (void *)((wxLog *) ((wxLogChain *) x));
37585 }
37586 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37587 return (void *)((wxLog *) ((wxLogGui *) x));
37588 }
37589 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37590 return (void *)((wxLog *) ((wxPyLog *) x));
37591 }
37592 static void *_p_wxControlTo_p_wxWindow(void *x) {
37593 return (void *)((wxWindow *) ((wxControl *) x));
37594 }
37595 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37596 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37597 }
37598 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37599 return (void *)((wxWindow *) ((wxMenuBar *) x));
37600 }
37601 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37602 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37603 }
37604 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37605 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37606 }
37607 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37608 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};
37609 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37610 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37611 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37612 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37613 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37614 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37616 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37617 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37618 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37619 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37620 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37621 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37630 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37631 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37632 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37633 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37634 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37635 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37636 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37637 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37638 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37639 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37640 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37641 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37642 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37643 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37644 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37645 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37646 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37647 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37667 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37668 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37669 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37670 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37671 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37672 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37673 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37674 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37675 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37676 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37677 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37679 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37680 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37681 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37682 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37683 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37684 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37701 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37702 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37703 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37704 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37705 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37706 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37707 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37708 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37709 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37710 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37711 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37712 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37713 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37714 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37715 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37716 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37717 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37718 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37719 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37720 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37721 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37722 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37723 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37724 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37725 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37726 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37727 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37728 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37729 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37730 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37731 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37732 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37733 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37734 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37735 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37736 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37737 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37738 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37739 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37740 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37741 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37759 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37760 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37761 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37762 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37763 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37764 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37765 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37766 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37767 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37768 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37769 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37770 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37771 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37772 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37773 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37774 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37775 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37776 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37777 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37778 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37779
37780 static swig_type_info *swig_type_initial[] = {
37781 &_swigt__p_char,
37782 &_swigt__p_form_ops_t,
37783 &_swigt__p_int,
37784 &_swigt__p_unsigned_char,
37785 &_swigt__p_unsigned_int,
37786 &_swigt__p_unsigned_long,
37787 &_swigt__p_void,
37788 &_swigt__p_wxANIHandler,
37789 &_swigt__p_wxAcceleratorTable,
37790 &_swigt__p_wxActivateEvent,
37791 &_swigt__p_wxArrayString,
37792 &_swigt__p_wxBMPHandler,
37793 &_swigt__p_wxBitmap,
37794 &_swigt__p_wxBitmapDataObject,
37795 &_swigt__p_wxBoxSizer,
37796 &_swigt__p_wxBusyCursor,
37797 &_swigt__p_wxBusyInfo,
37798 &_swigt__p_wxCURHandler,
37799 &_swigt__p_wxCaret,
37800 &_swigt__p_wxChar,
37801 &_swigt__p_wxChildFocusEvent,
37802 &_swigt__p_wxClipboard,
37803 &_swigt__p_wxClipboardLocker,
37804 &_swigt__p_wxClipboardTextEvent,
37805 &_swigt__p_wxCloseEvent,
37806 &_swigt__p_wxColour,
37807 &_swigt__p_wxCommandEvent,
37808 &_swigt__p_wxConfig,
37809 &_swigt__p_wxConfigBase,
37810 &_swigt__p_wxConfigPathChanger,
37811 &_swigt__p_wxContextMenuEvent,
37812 &_swigt__p_wxControl,
37813 &_swigt__p_wxControlWithItems,
37814 &_swigt__p_wxCursor,
37815 &_swigt__p_wxCustomDataObject,
37816 &_swigt__p_wxDC,
37817 &_swigt__p_wxDataFormat,
37818 &_swigt__p_wxDataObject,
37819 &_swigt__p_wxDataObjectComposite,
37820 &_swigt__p_wxDataObjectSimple,
37821 &_swigt__p_wxDateEvent,
37822 &_swigt__p_wxDateSpan,
37823 &_swigt__p_wxDateTime,
37824 &_swigt__p_wxDateTime__TimeZone,
37825 &_swigt__p_wxDisplay,
37826 &_swigt__p_wxDisplayChangedEvent,
37827 &_swigt__p_wxDropFilesEvent,
37828 &_swigt__p_wxDuplexMode,
37829 &_swigt__p_wxEraseEvent,
37830 &_swigt__p_wxEvent,
37831 &_swigt__p_wxEvtHandler,
37832 &_swigt__p_wxFSFile,
37833 &_swigt__p_wxFileConfig,
37834 &_swigt__p_wxFileDataObject,
37835 &_swigt__p_wxFileHistory,
37836 &_swigt__p_wxFileSystem,
37837 &_swigt__p_wxFileType,
37838 &_swigt__p_wxFileTypeInfo,
37839 &_swigt__p_wxFlexGridSizer,
37840 &_swigt__p_wxFocusEvent,
37841 &_swigt__p_wxFont,
37842 &_swigt__p_wxFrame,
37843 &_swigt__p_wxGBSizerItem,
37844 &_swigt__p_wxGIFHandler,
37845 &_swigt__p_wxGridBagSizer,
37846 &_swigt__p_wxGridSizer,
37847 &_swigt__p_wxICOHandler,
37848 &_swigt__p_wxIcon,
37849 &_swigt__p_wxIconizeEvent,
37850 &_swigt__p_wxIdleEvent,
37851 &_swigt__p_wxImage,
37852 &_swigt__p_wxImageHandler,
37853 &_swigt__p_wxIndividualLayoutConstraint,
37854 &_swigt__p_wxInitDialogEvent,
37855 &_swigt__p_wxJPEGHandler,
37856 &_swigt__p_wxJoystick,
37857 &_swigt__p_wxJoystickEvent,
37858 &_swigt__p_wxKeyEvent,
37859 &_swigt__p_wxKillError,
37860 &_swigt__p_wxLayoutConstraints,
37861 &_swigt__p_wxLog,
37862 &_swigt__p_wxLogBuffer,
37863 &_swigt__p_wxLogChain,
37864 &_swigt__p_wxLogGui,
37865 &_swigt__p_wxLogNull,
37866 &_swigt__p_wxLogStderr,
37867 &_swigt__p_wxLogTextCtrl,
37868 &_swigt__p_wxLogWindow,
37869 &_swigt__p_wxMaximizeEvent,
37870 &_swigt__p_wxMemorySize,
37871 &_swigt__p_wxMenu,
37872 &_swigt__p_wxMenuBar,
37873 &_swigt__p_wxMenuEvent,
37874 &_swigt__p_wxMenuItem,
37875 &_swigt__p_wxMetafile,
37876 &_swigt__p_wxMetafileDataObject,
37877 &_swigt__p_wxMimeTypesManager,
37878 &_swigt__p_wxMouseCaptureChangedEvent,
37879 &_swigt__p_wxMouseEvent,
37880 &_swigt__p_wxMouseState,
37881 &_swigt__p_wxMoveEvent,
37882 &_swigt__p_wxMutexGuiLocker,
37883 &_swigt__p_wxNavigationKeyEvent,
37884 &_swigt__p_wxNcPaintEvent,
37885 &_swigt__p_wxNotifyEvent,
37886 &_swigt__p_wxObject,
37887 &_swigt__p_wxOutputStream,
37888 &_swigt__p_wxPCXHandler,
37889 &_swigt__p_wxPNGHandler,
37890 &_swigt__p_wxPNMHandler,
37891 &_swigt__p_wxPaintEvent,
37892 &_swigt__p_wxPaletteChangedEvent,
37893 &_swigt__p_wxPaperSize,
37894 &_swigt__p_wxPoint,
37895 &_swigt__p_wxPowerEvent,
37896 &_swigt__p_wxProcessEvent,
37897 &_swigt__p_wxPyApp,
37898 &_swigt__p_wxPyArtProvider,
37899 &_swigt__p_wxPyBitmapDataObject,
37900 &_swigt__p_wxPyCommandEvent,
37901 &_swigt__p_wxPyDataObjectSimple,
37902 &_swigt__p_wxPyDropSource,
37903 &_swigt__p_wxPyDropTarget,
37904 &_swigt__p_wxPyEvent,
37905 &_swigt__p_wxPyFileDropTarget,
37906 &_swigt__p_wxPyImageHandler,
37907 &_swigt__p_wxPyLog,
37908 &_swigt__p_wxPyProcess,
37909 &_swigt__p_wxPySizer,
37910 &_swigt__p_wxPyTextDataObject,
37911 &_swigt__p_wxPyTextDropTarget,
37912 &_swigt__p_wxPyTimer,
37913 &_swigt__p_wxPyTipProvider,
37914 &_swigt__p_wxPyValidator,
37915 &_swigt__p_wxQueryNewPaletteEvent,
37916 &_swigt__p_wxRect,
37917 &_swigt__p_wxScrollEvent,
37918 &_swigt__p_wxScrollWinEvent,
37919 &_swigt__p_wxSetCursorEvent,
37920 &_swigt__p_wxShowEvent,
37921 &_swigt__p_wxSingleInstanceChecker,
37922 &_swigt__p_wxSize,
37923 &_swigt__p_wxSizeEvent,
37924 &_swigt__p_wxSizer,
37925 &_swigt__p_wxSizerItem,
37926 &_swigt__p_wxSound,
37927 &_swigt__p_wxStandardPaths,
37928 &_swigt__p_wxStaticBoxSizer,
37929 &_swigt__p_wxStdDialogButtonSizer,
37930 &_swigt__p_wxStopWatch,
37931 &_swigt__p_wxString,
37932 &_swigt__p_wxSysColourChangedEvent,
37933 &_swigt__p_wxSystemOptions,
37934 &_swigt__p_wxSystemSettings,
37935 &_swigt__p_wxTIFFHandler,
37936 &_swigt__p_wxTextCtrl,
37937 &_swigt__p_wxTextDataObject,
37938 &_swigt__p_wxTimeSpan,
37939 &_swigt__p_wxTimer,
37940 &_swigt__p_wxTimerEvent,
37941 &_swigt__p_wxTimerRunner,
37942 &_swigt__p_wxTipProvider,
37943 &_swigt__p_wxToolTip,
37944 &_swigt__p_wxURLDataObject,
37945 &_swigt__p_wxUpdateUIEvent,
37946 &_swigt__p_wxValidator,
37947 &_swigt__p_wxVideoMode,
37948 &_swigt__p_wxWindow,
37949 &_swigt__p_wxWindowCreateEvent,
37950 &_swigt__p_wxWindowDestroyEvent,
37951 &_swigt__p_wxWindowDisabler,
37952 &_swigt__p_wxXPMHandler,
37953 };
37954
37955 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37956 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37957 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37958 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37959 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37960 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37962 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37963 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37964 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}};
37965 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37966 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37967 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37968 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37969 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37970 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37971 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37972 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37973 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}};
37974 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37975 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37978 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37979 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}};
37980 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37981 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}};
37982 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38015 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38016 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38021 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38024 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}};
38025 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38031 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}};
38032 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38033 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38043 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}};
38044 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38048 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38049 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38050 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38051 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
38052 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38053 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38054 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38055 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38056 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38057 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38058 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38059 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38060 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38061 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38062 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38063 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38064 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38065 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38066 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38067 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38068 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38069 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38070 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38071 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38080 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38081 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38088 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}};
38089 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38095 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38098 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}};
38099 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38116 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}};
38117 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38121 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}};
38122 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38125 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}};
38126 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38127
38128 static swig_cast_info *swig_cast_initial[] = {
38129 _swigc__p_char,
38130 _swigc__p_form_ops_t,
38131 _swigc__p_int,
38132 _swigc__p_unsigned_char,
38133 _swigc__p_unsigned_int,
38134 _swigc__p_unsigned_long,
38135 _swigc__p_void,
38136 _swigc__p_wxANIHandler,
38137 _swigc__p_wxAcceleratorTable,
38138 _swigc__p_wxActivateEvent,
38139 _swigc__p_wxArrayString,
38140 _swigc__p_wxBMPHandler,
38141 _swigc__p_wxBitmap,
38142 _swigc__p_wxBitmapDataObject,
38143 _swigc__p_wxBoxSizer,
38144 _swigc__p_wxBusyCursor,
38145 _swigc__p_wxBusyInfo,
38146 _swigc__p_wxCURHandler,
38147 _swigc__p_wxCaret,
38148 _swigc__p_wxChar,
38149 _swigc__p_wxChildFocusEvent,
38150 _swigc__p_wxClipboard,
38151 _swigc__p_wxClipboardLocker,
38152 _swigc__p_wxClipboardTextEvent,
38153 _swigc__p_wxCloseEvent,
38154 _swigc__p_wxColour,
38155 _swigc__p_wxCommandEvent,
38156 _swigc__p_wxConfig,
38157 _swigc__p_wxConfigBase,
38158 _swigc__p_wxConfigPathChanger,
38159 _swigc__p_wxContextMenuEvent,
38160 _swigc__p_wxControl,
38161 _swigc__p_wxControlWithItems,
38162 _swigc__p_wxCursor,
38163 _swigc__p_wxCustomDataObject,
38164 _swigc__p_wxDC,
38165 _swigc__p_wxDataFormat,
38166 _swigc__p_wxDataObject,
38167 _swigc__p_wxDataObjectComposite,
38168 _swigc__p_wxDataObjectSimple,
38169 _swigc__p_wxDateEvent,
38170 _swigc__p_wxDateSpan,
38171 _swigc__p_wxDateTime,
38172 _swigc__p_wxDateTime__TimeZone,
38173 _swigc__p_wxDisplay,
38174 _swigc__p_wxDisplayChangedEvent,
38175 _swigc__p_wxDropFilesEvent,
38176 _swigc__p_wxDuplexMode,
38177 _swigc__p_wxEraseEvent,
38178 _swigc__p_wxEvent,
38179 _swigc__p_wxEvtHandler,
38180 _swigc__p_wxFSFile,
38181 _swigc__p_wxFileConfig,
38182 _swigc__p_wxFileDataObject,
38183 _swigc__p_wxFileHistory,
38184 _swigc__p_wxFileSystem,
38185 _swigc__p_wxFileType,
38186 _swigc__p_wxFileTypeInfo,
38187 _swigc__p_wxFlexGridSizer,
38188 _swigc__p_wxFocusEvent,
38189 _swigc__p_wxFont,
38190 _swigc__p_wxFrame,
38191 _swigc__p_wxGBSizerItem,
38192 _swigc__p_wxGIFHandler,
38193 _swigc__p_wxGridBagSizer,
38194 _swigc__p_wxGridSizer,
38195 _swigc__p_wxICOHandler,
38196 _swigc__p_wxIcon,
38197 _swigc__p_wxIconizeEvent,
38198 _swigc__p_wxIdleEvent,
38199 _swigc__p_wxImage,
38200 _swigc__p_wxImageHandler,
38201 _swigc__p_wxIndividualLayoutConstraint,
38202 _swigc__p_wxInitDialogEvent,
38203 _swigc__p_wxJPEGHandler,
38204 _swigc__p_wxJoystick,
38205 _swigc__p_wxJoystickEvent,
38206 _swigc__p_wxKeyEvent,
38207 _swigc__p_wxKillError,
38208 _swigc__p_wxLayoutConstraints,
38209 _swigc__p_wxLog,
38210 _swigc__p_wxLogBuffer,
38211 _swigc__p_wxLogChain,
38212 _swigc__p_wxLogGui,
38213 _swigc__p_wxLogNull,
38214 _swigc__p_wxLogStderr,
38215 _swigc__p_wxLogTextCtrl,
38216 _swigc__p_wxLogWindow,
38217 _swigc__p_wxMaximizeEvent,
38218 _swigc__p_wxMemorySize,
38219 _swigc__p_wxMenu,
38220 _swigc__p_wxMenuBar,
38221 _swigc__p_wxMenuEvent,
38222 _swigc__p_wxMenuItem,
38223 _swigc__p_wxMetafile,
38224 _swigc__p_wxMetafileDataObject,
38225 _swigc__p_wxMimeTypesManager,
38226 _swigc__p_wxMouseCaptureChangedEvent,
38227 _swigc__p_wxMouseEvent,
38228 _swigc__p_wxMouseState,
38229 _swigc__p_wxMoveEvent,
38230 _swigc__p_wxMutexGuiLocker,
38231 _swigc__p_wxNavigationKeyEvent,
38232 _swigc__p_wxNcPaintEvent,
38233 _swigc__p_wxNotifyEvent,
38234 _swigc__p_wxObject,
38235 _swigc__p_wxOutputStream,
38236 _swigc__p_wxPCXHandler,
38237 _swigc__p_wxPNGHandler,
38238 _swigc__p_wxPNMHandler,
38239 _swigc__p_wxPaintEvent,
38240 _swigc__p_wxPaletteChangedEvent,
38241 _swigc__p_wxPaperSize,
38242 _swigc__p_wxPoint,
38243 _swigc__p_wxPowerEvent,
38244 _swigc__p_wxProcessEvent,
38245 _swigc__p_wxPyApp,
38246 _swigc__p_wxPyArtProvider,
38247 _swigc__p_wxPyBitmapDataObject,
38248 _swigc__p_wxPyCommandEvent,
38249 _swigc__p_wxPyDataObjectSimple,
38250 _swigc__p_wxPyDropSource,
38251 _swigc__p_wxPyDropTarget,
38252 _swigc__p_wxPyEvent,
38253 _swigc__p_wxPyFileDropTarget,
38254 _swigc__p_wxPyImageHandler,
38255 _swigc__p_wxPyLog,
38256 _swigc__p_wxPyProcess,
38257 _swigc__p_wxPySizer,
38258 _swigc__p_wxPyTextDataObject,
38259 _swigc__p_wxPyTextDropTarget,
38260 _swigc__p_wxPyTimer,
38261 _swigc__p_wxPyTipProvider,
38262 _swigc__p_wxPyValidator,
38263 _swigc__p_wxQueryNewPaletteEvent,
38264 _swigc__p_wxRect,
38265 _swigc__p_wxScrollEvent,
38266 _swigc__p_wxScrollWinEvent,
38267 _swigc__p_wxSetCursorEvent,
38268 _swigc__p_wxShowEvent,
38269 _swigc__p_wxSingleInstanceChecker,
38270 _swigc__p_wxSize,
38271 _swigc__p_wxSizeEvent,
38272 _swigc__p_wxSizer,
38273 _swigc__p_wxSizerItem,
38274 _swigc__p_wxSound,
38275 _swigc__p_wxStandardPaths,
38276 _swigc__p_wxStaticBoxSizer,
38277 _swigc__p_wxStdDialogButtonSizer,
38278 _swigc__p_wxStopWatch,
38279 _swigc__p_wxString,
38280 _swigc__p_wxSysColourChangedEvent,
38281 _swigc__p_wxSystemOptions,
38282 _swigc__p_wxSystemSettings,
38283 _swigc__p_wxTIFFHandler,
38284 _swigc__p_wxTextCtrl,
38285 _swigc__p_wxTextDataObject,
38286 _swigc__p_wxTimeSpan,
38287 _swigc__p_wxTimer,
38288 _swigc__p_wxTimerEvent,
38289 _swigc__p_wxTimerRunner,
38290 _swigc__p_wxTipProvider,
38291 _swigc__p_wxToolTip,
38292 _swigc__p_wxURLDataObject,
38293 _swigc__p_wxUpdateUIEvent,
38294 _swigc__p_wxValidator,
38295 _swigc__p_wxVideoMode,
38296 _swigc__p_wxWindow,
38297 _swigc__p_wxWindowCreateEvent,
38298 _swigc__p_wxWindowDestroyEvent,
38299 _swigc__p_wxWindowDisabler,
38300 _swigc__p_wxXPMHandler,
38301 };
38302
38303
38304 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38305
38306 static swig_const_info swig_const_table[] = {
38307 {0, 0, 0, 0.0, 0, 0}};
38308
38309 #ifdef __cplusplus
38310 }
38311 #endif
38312 /* -----------------------------------------------------------------------------
38313 * Type initialization:
38314 * This problem is tough by the requirement that no dynamic
38315 * memory is used. Also, since swig_type_info structures store pointers to
38316 * swig_cast_info structures and swig_cast_info structures store pointers back
38317 * to swig_type_info structures, we need some lookup code at initialization.
38318 * The idea is that swig generates all the structures that are needed.
38319 * The runtime then collects these partially filled structures.
38320 * The SWIG_InitializeModule function takes these initial arrays out of
38321 * swig_module, and does all the lookup, filling in the swig_module.types
38322 * array with the correct data and linking the correct swig_cast_info
38323 * structures together.
38324 *
38325 * The generated swig_type_info structures are assigned staticly to an initial
38326 * array. We just loop though that array, and handle each type individually.
38327 * First we lookup if this type has been already loaded, and if so, use the
38328 * loaded structure instead of the generated one. Then we have to fill in the
38329 * cast linked list. The cast data is initially stored in something like a
38330 * two-dimensional array. Each row corresponds to a type (there are the same
38331 * number of rows as there are in the swig_type_initial array). Each entry in
38332 * a column is one of the swig_cast_info structures for that type.
38333 * The cast_initial array is actually an array of arrays, because each row has
38334 * a variable number of columns. So to actually build the cast linked list,
38335 * we find the array of casts associated with the type, and loop through it
38336 * adding the casts to the list. The one last trick we need to do is making
38337 * sure the type pointer in the swig_cast_info struct is correct.
38338 *
38339 * First off, we lookup the cast->type name to see if it is already loaded.
38340 * There are three cases to handle:
38341 * 1) If the cast->type has already been loaded AND the type we are adding
38342 * casting info to has not been loaded (it is in this module), THEN we
38343 * replace the cast->type pointer with the type pointer that has already
38344 * been loaded.
38345 * 2) If BOTH types (the one we are adding casting info to, and the
38346 * cast->type) are loaded, THEN the cast info has already been loaded by
38347 * the previous module so we just ignore it.
38348 * 3) Finally, if cast->type has not already been loaded, then we add that
38349 * swig_cast_info to the linked list (because the cast->type) pointer will
38350 * be correct.
38351 * ----------------------------------------------------------------------------- */
38352
38353 #ifdef __cplusplus
38354 extern "C" {
38355 #if 0
38356 } /* c-mode */
38357 #endif
38358 #endif
38359
38360 #if 0
38361 #define SWIGRUNTIME_DEBUG
38362 #endif
38363
38364 SWIGRUNTIME void
38365 SWIG_InitializeModule(void *clientdata) {
38366 size_t i;
38367 swig_module_info *module_head;
38368 static int init_run = 0;
38369
38370 clientdata = clientdata;
38371
38372 if (init_run) return;
38373 init_run = 1;
38374
38375 /* Initialize the swig_module */
38376 swig_module.type_initial = swig_type_initial;
38377 swig_module.cast_initial = swig_cast_initial;
38378
38379 /* Try and load any already created modules */
38380 module_head = SWIG_GetModule(clientdata);
38381 if (module_head) {
38382 swig_module.next = module_head->next;
38383 module_head->next = &swig_module;
38384 } else {
38385 /* This is the first module loaded */
38386 swig_module.next = &swig_module;
38387 SWIG_SetModule(clientdata, &swig_module);
38388 }
38389
38390 /* Now work on filling in swig_module.types */
38391 #ifdef SWIGRUNTIME_DEBUG
38392 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38393 #endif
38394 for (i = 0; i < swig_module.size; ++i) {
38395 swig_type_info *type = 0;
38396 swig_type_info *ret;
38397 swig_cast_info *cast;
38398
38399 #ifdef SWIGRUNTIME_DEBUG
38400 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38401 #endif
38402
38403 /* if there is another module already loaded */
38404 if (swig_module.next != &swig_module) {
38405 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38406 }
38407 if (type) {
38408 /* Overwrite clientdata field */
38409 #ifdef SWIGRUNTIME_DEBUG
38410 printf("SWIG_InitializeModule: found type %s\n", type->name);
38411 #endif
38412 if (swig_module.type_initial[i]->clientdata) {
38413 type->clientdata = swig_module.type_initial[i]->clientdata;
38414 #ifdef SWIGRUNTIME_DEBUG
38415 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38416 #endif
38417 }
38418 } else {
38419 type = swig_module.type_initial[i];
38420 }
38421
38422 /* Insert casting types */
38423 cast = swig_module.cast_initial[i];
38424 while (cast->type) {
38425 /* Don't need to add information already in the list */
38426 ret = 0;
38427 #ifdef SWIGRUNTIME_DEBUG
38428 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38429 #endif
38430 if (swig_module.next != &swig_module) {
38431 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38432 #ifdef SWIGRUNTIME_DEBUG
38433 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38434 #endif
38435 }
38436 if (ret) {
38437 if (type == swig_module.type_initial[i]) {
38438 #ifdef SWIGRUNTIME_DEBUG
38439 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38440 #endif
38441 cast->type = ret;
38442 ret = 0;
38443 } else {
38444 /* Check for casting already in the list */
38445 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38446 #ifdef SWIGRUNTIME_DEBUG
38447 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38448 #endif
38449 if (!ocast) ret = 0;
38450 }
38451 }
38452
38453 if (!ret) {
38454 #ifdef SWIGRUNTIME_DEBUG
38455 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38456 #endif
38457 if (type->cast) {
38458 type->cast->prev = cast;
38459 cast->next = type->cast;
38460 }
38461 type->cast = cast;
38462 }
38463 cast++;
38464 }
38465 /* Set entry in modules->types array equal to the type */
38466 swig_module.types[i] = type;
38467 }
38468 swig_module.types[i] = 0;
38469
38470 #ifdef SWIGRUNTIME_DEBUG
38471 printf("**** SWIG_InitializeModule: Cast List ******\n");
38472 for (i = 0; i < swig_module.size; ++i) {
38473 int j = 0;
38474 swig_cast_info *cast = swig_module.cast_initial[i];
38475 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38476 while (cast->type) {
38477 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38478 cast++;
38479 ++j;
38480 }
38481 printf("---- Total casts: %d\n",j);
38482 }
38483 printf("**** SWIG_InitializeModule: Cast List ******\n");
38484 #endif
38485 }
38486
38487 /* This function will propagate the clientdata field of type to
38488 * any new swig_type_info structures that have been added into the list
38489 * of equivalent types. It is like calling
38490 * SWIG_TypeClientData(type, clientdata) a second time.
38491 */
38492 SWIGRUNTIME void
38493 SWIG_PropagateClientData(void) {
38494 size_t i;
38495 swig_cast_info *equiv;
38496 static int init_run = 0;
38497
38498 if (init_run) return;
38499 init_run = 1;
38500
38501 for (i = 0; i < swig_module.size; i++) {
38502 if (swig_module.types[i]->clientdata) {
38503 equiv = swig_module.types[i]->cast;
38504 while (equiv) {
38505 if (!equiv->converter) {
38506 if (equiv->type && !equiv->type->clientdata)
38507 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38508 }
38509 equiv = equiv->next;
38510 }
38511 }
38512 }
38513 }
38514
38515 #ifdef __cplusplus
38516 #if 0
38517 {
38518 /* c-mode */
38519 #endif
38520 }
38521 #endif
38522
38523
38524
38525 #ifdef __cplusplus
38526 extern "C" {
38527 #endif
38528
38529 /* Python-specific SWIG API */
38530 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38531 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38532 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38533
38534 /* -----------------------------------------------------------------------------
38535 * global variable support code.
38536 * ----------------------------------------------------------------------------- */
38537
38538 typedef struct swig_globalvar {
38539 char *name; /* Name of global variable */
38540 PyObject *(*get_attr)(void); /* Return the current value */
38541 int (*set_attr)(PyObject *); /* Set the value */
38542 struct swig_globalvar *next;
38543 } swig_globalvar;
38544
38545 typedef struct swig_varlinkobject {
38546 PyObject_HEAD
38547 swig_globalvar *vars;
38548 } swig_varlinkobject;
38549
38550 SWIGINTERN PyObject *
38551 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38552 return PyString_FromString("<Swig global variables>");
38553 }
38554
38555 SWIGINTERN PyObject *
38556 swig_varlink_str(swig_varlinkobject *v) {
38557 PyObject *str = PyString_FromString("(");
38558 swig_globalvar *var;
38559 for (var = v->vars; var; var=var->next) {
38560 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38561 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38562 }
38563 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38564 return str;
38565 }
38566
38567 SWIGINTERN int
38568 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38569 PyObject *str = swig_varlink_str(v);
38570 fprintf(fp,"Swig global variables ");
38571 fprintf(fp,"%s\n", PyString_AsString(str));
38572 Py_DECREF(str);
38573 return 0;
38574 }
38575
38576 SWIGINTERN void
38577 swig_varlink_dealloc(swig_varlinkobject *v) {
38578 swig_globalvar *var = v->vars;
38579 while (var) {
38580 swig_globalvar *n = var->next;
38581 free(var->name);
38582 free(var);
38583 var = n;
38584 }
38585 }
38586
38587 SWIGINTERN PyObject *
38588 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38589 PyObject *res = NULL;
38590 swig_globalvar *var = v->vars;
38591 while (var) {
38592 if (strcmp(var->name,n) == 0) {
38593 res = (*var->get_attr)();
38594 break;
38595 }
38596 var = var->next;
38597 }
38598 if (res == NULL && !PyErr_Occurred()) {
38599 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38600 }
38601 return res;
38602 }
38603
38604 SWIGINTERN int
38605 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38606 int res = 1;
38607 swig_globalvar *var = v->vars;
38608 while (var) {
38609 if (strcmp(var->name,n) == 0) {
38610 res = (*var->set_attr)(p);
38611 break;
38612 }
38613 var = var->next;
38614 }
38615 if (res == 1 && !PyErr_Occurred()) {
38616 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38617 }
38618 return res;
38619 }
38620
38621 SWIGINTERN PyTypeObject*
38622 swig_varlink_type(void) {
38623 static char varlink__doc__[] = "Swig var link object";
38624 static PyTypeObject varlink_type;
38625 static int type_init = 0;
38626 if (!type_init) {
38627 const PyTypeObject tmp
38628 = {
38629 PyObject_HEAD_INIT(NULL)
38630 0, /* Number of items in variable part (ob_size) */
38631 (char *)"swigvarlink", /* Type name (tp_name) */
38632 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38633 0, /* Itemsize (tp_itemsize) */
38634 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38635 (printfunc) swig_varlink_print, /* Print (tp_print) */
38636 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38637 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38638 0, /* tp_compare */
38639 (reprfunc) swig_varlink_repr, /* tp_repr */
38640 0, /* tp_as_number */
38641 0, /* tp_as_sequence */
38642 0, /* tp_as_mapping */
38643 0, /* tp_hash */
38644 0, /* tp_call */
38645 (reprfunc)swig_varlink_str, /* tp_str */
38646 0, /* tp_getattro */
38647 0, /* tp_setattro */
38648 0, /* tp_as_buffer */
38649 0, /* tp_flags */
38650 varlink__doc__, /* tp_doc */
38651 0, /* tp_traverse */
38652 0, /* tp_clear */
38653 0, /* tp_richcompare */
38654 0, /* tp_weaklistoffset */
38655 #if PY_VERSION_HEX >= 0x02020000
38656 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38657 #endif
38658 #if PY_VERSION_HEX >= 0x02030000
38659 0, /* tp_del */
38660 #endif
38661 #ifdef COUNT_ALLOCS
38662 0,0,0,0 /* tp_alloc -> tp_next */
38663 #endif
38664 };
38665 varlink_type = tmp;
38666 varlink_type.ob_type = &PyType_Type;
38667 type_init = 1;
38668 }
38669 return &varlink_type;
38670 }
38671
38672 /* Create a variable linking object for use later */
38673 SWIGINTERN PyObject *
38674 SWIG_Python_newvarlink(void) {
38675 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38676 if (result) {
38677 result->vars = 0;
38678 }
38679 return ((PyObject*) result);
38680 }
38681
38682 SWIGINTERN void
38683 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38684 swig_varlinkobject *v = (swig_varlinkobject *) p;
38685 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38686 if (gv) {
38687 size_t size = strlen(name)+1;
38688 gv->name = (char *)malloc(size);
38689 if (gv->name) {
38690 strncpy(gv->name,name,size);
38691 gv->get_attr = get_attr;
38692 gv->set_attr = set_attr;
38693 gv->next = v->vars;
38694 }
38695 }
38696 v->vars = gv;
38697 }
38698
38699 SWIGINTERN PyObject *
38700 SWIG_globals() {
38701 static PyObject *_SWIG_globals = 0;
38702 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38703 return _SWIG_globals;
38704 }
38705
38706 /* -----------------------------------------------------------------------------
38707 * constants/methods manipulation
38708 * ----------------------------------------------------------------------------- */
38709
38710 /* Install Constants */
38711 SWIGINTERN void
38712 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38713 PyObject *obj = 0;
38714 size_t i;
38715 for (i = 0; constants[i].type; ++i) {
38716 switch(constants[i].type) {
38717 case SWIG_PY_POINTER:
38718 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38719 break;
38720 case SWIG_PY_BINARY:
38721 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38722 break;
38723 default:
38724 obj = 0;
38725 break;
38726 }
38727 if (obj) {
38728 PyDict_SetItemString(d, constants[i].name, obj);
38729 Py_DECREF(obj);
38730 }
38731 }
38732 }
38733
38734 /* -----------------------------------------------------------------------------*/
38735 /* Fix SwigMethods to carry the callback ptrs when needed */
38736 /* -----------------------------------------------------------------------------*/
38737
38738 SWIGINTERN void
38739 SWIG_Python_FixMethods(PyMethodDef *methods,
38740 swig_const_info *const_table,
38741 swig_type_info **types,
38742 swig_type_info **types_initial) {
38743 size_t i;
38744 for (i = 0; methods[i].ml_name; ++i) {
38745 char *c = methods[i].ml_doc;
38746 if (c && (c = strstr(c, "swig_ptr: "))) {
38747 int j;
38748 swig_const_info *ci = 0;
38749 char *name = c + 10;
38750 for (j = 0; const_table[j].type; ++j) {
38751 if (strncmp(const_table[j].name, name,
38752 strlen(const_table[j].name)) == 0) {
38753 ci = &(const_table[j]);
38754 break;
38755 }
38756 }
38757 if (ci) {
38758 size_t shift = (ci->ptype) - types;
38759 swig_type_info *ty = types_initial[shift];
38760 size_t ldoc = (c - methods[i].ml_doc);
38761 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38762 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38763 if (ndoc) {
38764 char *buff = ndoc;
38765 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38766 if (ptr) {
38767 strncpy(buff, methods[i].ml_doc, ldoc);
38768 buff += ldoc;
38769 strncpy(buff, "swig_ptr: ", 10);
38770 buff += 10;
38771 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38772 methods[i].ml_doc = ndoc;
38773 }
38774 }
38775 }
38776 }
38777 }
38778 }
38779
38780 #ifdef __cplusplus
38781 }
38782 #endif
38783
38784 /* -----------------------------------------------------------------------------*
38785 * Partial Init method
38786 * -----------------------------------------------------------------------------*/
38787
38788 #ifdef __cplusplus
38789 extern "C"
38790 #endif
38791 SWIGEXPORT void SWIG_init(void) {
38792 PyObject *m, *d;
38793
38794 /* Fix SwigMethods to carry the callback ptrs when needed */
38795 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38796
38797 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38798 d = PyModule_GetDict(m);
38799
38800 SWIG_InitializeModule(0);
38801 SWIG_InstallConstants(d,swig_const_table);
38802
38803
38804 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38805 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38806 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38807 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38808 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38809 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38810 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38811 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38812 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38813 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38814 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38815 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38816 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38817 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38818 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38819 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38820 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38821 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38822 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38823 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38824 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38825 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38826 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38827 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38828 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38829 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38830 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38831 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38832 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38833 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38834 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38835 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38836 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38837 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38838 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38839 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38840 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38841 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38842 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38843 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38844 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38845 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38846 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38847 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38848 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38849 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38850 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38851 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38852 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38853 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38854 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38855 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38856 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38857 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38858 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38859 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38860 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38861 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38862 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38863 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38864 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38865 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38866 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38867 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38868 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38869 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38870 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38871 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38872 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38873 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38874 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38875 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38876 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38877 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38878 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38879 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38880 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38881 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38882 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38883 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38884 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38885 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38886 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38887 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38888 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38889 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38890 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38891 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38892 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38893 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38894 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38895 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38896 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38897 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38898 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38899 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38900 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38901 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38902 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38903 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38904 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38905 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38906
38907 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38908
38909 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38910 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38911 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38912 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38913 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38914 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38915 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38916 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38917 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38918 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38919 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38920 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38921 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38922 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38923 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38924 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38925 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38926 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38927 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38928 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38929 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38930 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38931 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38932 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38933 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38934 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38935 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38936 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38937 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38938 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38939 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38940 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38941 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38942 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38943 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38944 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38945 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38946 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38947 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38948 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38949 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38950 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38951 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38952 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38953 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38954 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38955 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38956 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38957 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38958 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38959 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38960 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38961 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38962
38963 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38964
38965 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38966 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38967 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38968 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38969 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38970 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38971 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38972 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38973 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38974 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38975 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38976 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38977 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38978 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38979 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38980 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38981 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38982 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38983 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38984 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38985 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38986 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38987 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38988 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38989 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38990 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38991 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38992 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38993 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38994 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38995 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38996 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38997 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38998 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38999 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39000 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39001 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39002 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39003 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39004 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39005 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39006 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39007 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39008 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39009 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39010 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39011 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39012 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39013 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39014 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39016 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39017 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39018 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39019 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39020 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39021 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39022 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39023 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39024 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39025 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39026 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39027 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39028 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39029 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39030 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39031 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39032 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39033 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39034 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39035 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39036 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39037 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39038 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39039 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39040 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39041
39042 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39043
39044 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39045 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39046 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39047 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39048 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39049 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39050 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39051 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39052 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39053 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39054 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39055 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39056 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39057 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39058 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39059 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39060 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39061 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39062 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39063 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39064 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39065 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39066 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39067 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39068 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39069 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39070 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39071 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39072 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39073 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39074 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39075 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39076 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39077 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39078 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39079 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39080 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39081 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39082 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39083 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39084 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39085 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39086 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39087 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39088 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39089 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39090 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39091 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39092 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39093 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39094 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39095 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39096 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39097 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39098 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39099 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39100 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39101 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39102 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39103 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39104 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39105 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39106 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39107 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39108 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39109 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39110 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39111 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39112 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39113 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39114 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39115 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39116 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39117 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39118 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39119 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39120 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39121 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39122 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39123 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39124 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39125 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39126 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39127 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39128 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39129 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39130 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39131 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39132 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39133 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39134 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39135 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39136 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39137 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39138 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39139 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39140 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39141 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39142 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39143 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39144 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39145 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39146 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39147 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39148 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39149 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39150 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39151 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39152 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39153 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39154 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39155 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39156 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39157 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39158 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39159 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39160 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39161 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39162 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39163 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39164 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39165 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39166 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39167 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39168 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39169 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39170 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39171 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39172 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39173 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39174 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39175 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39176 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39177 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39178 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39179 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39180 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39181 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39182 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39183 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39184 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39185 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39186 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39187 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39188 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39189 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39190 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39191 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39192 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39193 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39194 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39195 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39196 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39197 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39198 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39199 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39200 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39201 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39202 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39203 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39204 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39205 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39206 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39207 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39208 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39209 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39210 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39211 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39212 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39213 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39214 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39215 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39216 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39217 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39218 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39219 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39220 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39221 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39222 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39223 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39224 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39225 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39226 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39227 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39228 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39229 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39230 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39231 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39232 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39233 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39234 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39235 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39236 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39237 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39238 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39239 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39240 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39241 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39242 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39243 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39244
39245 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39246 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39247 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39248 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39249
39250 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39251 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39252 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39253 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39254 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39255 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39256 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39257 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39258 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39259 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39260 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39261 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39262 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39263 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39264 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39265 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39266 }
39267
wxWidgets (Impactor)