]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* 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_wxCloseEvent swig_types[23]
2486 #define SWIGTYPE_p_wxColour swig_types[24]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
2488 #define SWIGTYPE_p_wxConfig swig_types[26]
2489 #define SWIGTYPE_p_wxConfigBase swig_types[27]
2490 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2492 #define SWIGTYPE_p_wxControl swig_types[30]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2494 #define SWIGTYPE_p_wxCursor swig_types[32]
2495 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
2496 #define SWIGTYPE_p_wxDC swig_types[34]
2497 #define SWIGTYPE_p_wxDataFormat swig_types[35]
2498 #define SWIGTYPE_p_wxDataObject swig_types[36]
2499 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[39]
2502 #define SWIGTYPE_p_wxDateSpan swig_types[40]
2503 #define SWIGTYPE_p_wxDateTime swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
2505 #define SWIGTYPE_p_wxDisplay swig_types[43]
2506 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
2507 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
2509 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
2510 #define SWIGTYPE_p_wxEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
2512 #define SWIGTYPE_p_wxFSFile swig_types[50]
2513 #define SWIGTYPE_p_wxFileConfig swig_types[51]
2514 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
2515 #define SWIGTYPE_p_wxFileHistory swig_types[53]
2516 #define SWIGTYPE_p_wxFileSystem swig_types[54]
2517 #define SWIGTYPE_p_wxFileType swig_types[55]
2518 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
2519 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
2520 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
2521 #define SWIGTYPE_p_wxFont swig_types[59]
2522 #define SWIGTYPE_p_wxFrame swig_types[60]
2523 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
2524 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
2525 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
2526 #define SWIGTYPE_p_wxGridSizer swig_types[64]
2527 #define SWIGTYPE_p_wxICOHandler swig_types[65]
2528 #define SWIGTYPE_p_wxIcon swig_types[66]
2529 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
2530 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
2531 #define SWIGTYPE_p_wxImage swig_types[69]
2532 #define SWIGTYPE_p_wxImageHandler swig_types[70]
2533 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
2534 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
2536 #define SWIGTYPE_p_wxJoystick swig_types[74]
2537 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
2538 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKillError swig_types[77]
2540 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
2541 #define SWIGTYPE_p_wxLog swig_types[79]
2542 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
2543 #define SWIGTYPE_p_wxLogChain swig_types[81]
2544 #define SWIGTYPE_p_wxLogGui swig_types[82]
2545 #define SWIGTYPE_p_wxLogNull swig_types[83]
2546 #define SWIGTYPE_p_wxLogStderr swig_types[84]
2547 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
2548 #define SWIGTYPE_p_wxLogWindow swig_types[86]
2549 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
2550 #define SWIGTYPE_p_wxMemorySize swig_types[88]
2551 #define SWIGTYPE_p_wxMenu swig_types[89]
2552 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2553 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2555 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2556 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2557 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2558 #define SWIGTYPE_p_wxMouseEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseState swig_types[97]
2560 #define SWIGTYPE_p_wxMoveEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[99]
2562 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
2563 #define SWIGTYPE_p_wxNcPaintEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNotifyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxObject swig_types[103]
2566 #define SWIGTYPE_p_wxOutputStream swig_types[104]
2567 #define SWIGTYPE_p_wxPCXHandler swig_types[105]
2568 #define SWIGTYPE_p_wxPNGHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNMHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPaintEvent swig_types[108]
2571 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaperSize swig_types[110]
2573 #define SWIGTYPE_p_wxPoint swig_types[111]
2574 #define SWIGTYPE_p_wxProcessEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPyApp swig_types[113]
2576 #define SWIGTYPE_p_wxPyArtProvider swig_types[114]
2577 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[115]
2578 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
2579 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[117]
2580 #define SWIGTYPE_p_wxPyDropSource swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
2582 #define SWIGTYPE_p_wxPyEvent swig_types[120]
2583 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyImageHandler swig_types[122]
2585 #define SWIGTYPE_p_wxPyLog swig_types[123]
2586 #define SWIGTYPE_p_wxPyProcess swig_types[124]
2587 #define SWIGTYPE_p_wxPySizer swig_types[125]
2588 #define SWIGTYPE_p_wxPyTextDataObject swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[127]
2590 #define SWIGTYPE_p_wxPyTimer swig_types[128]
2591 #define SWIGTYPE_p_wxPyTipProvider swig_types[129]
2592 #define SWIGTYPE_p_wxPyValidator swig_types[130]
2593 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[131]
2594 #define SWIGTYPE_p_wxRect swig_types[132]
2595 #define SWIGTYPE_p_wxScrollEvent swig_types[133]
2596 #define SWIGTYPE_p_wxScrollWinEvent swig_types[134]
2597 #define SWIGTYPE_p_wxSetCursorEvent swig_types[135]
2598 #define SWIGTYPE_p_wxShowEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[137]
2600 #define SWIGTYPE_p_wxSize swig_types[138]
2601 #define SWIGTYPE_p_wxSizeEvent swig_types[139]
2602 #define SWIGTYPE_p_wxSizer swig_types[140]
2603 #define SWIGTYPE_p_wxSizerItem swig_types[141]
2604 #define SWIGTYPE_p_wxSound swig_types[142]
2605 #define SWIGTYPE_p_wxStandardPaths swig_types[143]
2606 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[144]
2607 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStopWatch swig_types[146]
2609 #define SWIGTYPE_p_wxString swig_types[147]
2610 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[148]
2611 #define SWIGTYPE_p_wxSystemOptions swig_types[149]
2612 #define SWIGTYPE_p_wxSystemSettings swig_types[150]
2613 #define SWIGTYPE_p_wxTIFFHandler swig_types[151]
2614 #define SWIGTYPE_p_wxTextCtrl swig_types[152]
2615 #define SWIGTYPE_p_wxTextDataObject swig_types[153]
2616 #define SWIGTYPE_p_wxTimeSpan swig_types[154]
2617 #define SWIGTYPE_p_wxTimer swig_types[155]
2618 #define SWIGTYPE_p_wxTimerEvent swig_types[156]
2619 #define SWIGTYPE_p_wxTimerRunner swig_types[157]
2620 #define SWIGTYPE_p_wxTipProvider swig_types[158]
2621 #define SWIGTYPE_p_wxToolTip swig_types[159]
2622 #define SWIGTYPE_p_wxURLDataObject swig_types[160]
2623 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[161]
2624 #define SWIGTYPE_p_wxValidator swig_types[162]
2625 #define SWIGTYPE_p_wxVideoMode swig_types[163]
2626 #define SWIGTYPE_p_wxWindow swig_types[164]
2627 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[165]
2628 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDisabler swig_types[167]
2630 #define SWIGTYPE_p_wxXPMHandler swig_types[168]
2631 static swig_type_info *swig_types[170];
2632 static swig_module_info swig_module = {swig_types, 169, 0, 0, 0, 0};
2633 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2634 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2635
2636 /* -------- TYPES TABLE (END) -------- */
2637
2638 #if (PY_VERSION_HEX <= 0x02000000)
2639 # if !defined(SWIG_PYTHON_CLASSIC)
2640 # error "This python version requires to use swig with the '-classic' option"
2641 # endif
2642 #endif
2643 #if (PY_VERSION_HEX <= 0x02020000)
2644 # error "This python version requires to use swig with the '-nomodern' option"
2645 #endif
2646 #if (PY_VERSION_HEX <= 0x02020000)
2647 # error "This python version requires to use swig with the '-nomodernargs' option"
2648 #endif
2649 #ifndef METH_O
2650 # error "This python version requires to use swig with the '-nofastunpack' option"
2651 #endif
2652
2653 /*-----------------------------------------------
2654 @(target):= _misc_.so
2655 ------------------------------------------------*/
2656 #define SWIG_init init_misc_
2657
2658 #define SWIG_name "_misc_"
2659
2660 #define SWIGVERSION 0x010329
2661
2662
2663 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2664 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2665
2666
2667 #include <stdexcept>
2668
2669
2670 namespace swig {
2671 class PyObject_ptr {
2672 protected:
2673 PyObject *_obj;
2674
2675 public:
2676 PyObject_ptr() :_obj(0)
2677 {
2678 }
2679
2680 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2681 {
2682 Py_XINCREF(_obj);
2683 }
2684
2685 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2686 {
2687 if (initial_ref) Py_XINCREF(_obj);
2688 }
2689
2690 PyObject_ptr & operator=(const PyObject_ptr& item)
2691 {
2692 Py_XINCREF(item._obj);
2693 Py_XDECREF(_obj);
2694 _obj = item._obj;
2695 return *this;
2696 }
2697
2698 ~PyObject_ptr()
2699 {
2700 Py_XDECREF(_obj);
2701 }
2702
2703 operator PyObject *() const
2704 {
2705 return _obj;
2706 }
2707
2708 PyObject *operator->() const
2709 {
2710 return _obj;
2711 }
2712 };
2713 }
2714
2715
2716 namespace swig {
2717 struct PyObject_var : PyObject_ptr {
2718 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2719
2720 PyObject_var & operator = (PyObject* obj)
2721 {
2722 Py_XDECREF(_obj);
2723 _obj = obj;
2724 return *this;
2725 }
2726 };
2727 }
2728
2729
2730 #include "wx/wxPython/wxPython.h"
2731 #include "wx/wxPython/pyclasses.h"
2732 #include "wx/wxPython/pyistream.h"
2733
2734 static const wxString wxPyEmptyString(wxEmptyString);
2735
2736
2737
2738 #define SWIG_From_long PyInt_FromLong
2739
2740
2741 SWIGINTERNINLINE PyObject *
2742 SWIG_From_int (int value)
2743 {
2744 return SWIG_From_long (value);
2745 }
2746
2747
2748 #include <limits.h>
2749 #ifndef LLONG_MIN
2750 # define LLONG_MIN LONG_LONG_MIN
2751 #endif
2752 #ifndef LLONG_MAX
2753 # define LLONG_MAX LONG_LONG_MAX
2754 #endif
2755 #ifndef ULLONG_MAX
2756 # define ULLONG_MAX ULONG_LONG_MAX
2757 #endif
2758
2759
2760 SWIGINTERN int
2761 SWIG_AsVal_long (PyObject* obj, long* val)
2762 {
2763 if (PyNumber_Check(obj)) {
2764 if (val) *val = PyInt_AsLong(obj);
2765 return SWIG_OK;
2766 }
2767 return SWIG_TypeError;
2768 }
2769
2770
2771 SWIGINTERN int
2772 SWIG_AsVal_int (PyObject * obj, int *val)
2773 {
2774 long v;
2775 int res = SWIG_AsVal_long (obj, &v);
2776 if (SWIG_IsOK(res)) {
2777 if ((v < INT_MIN || v > INT_MAX)) {
2778 return SWIG_OverflowError;
2779 } else {
2780 if (val) *val = static_cast< int >(v);
2781 }
2782 }
2783 return res;
2784 }
2785
2786 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2787
2788 #include <wx/stockitem.h>
2789
2790 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2791 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2792 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2793
2794 SWIGINTERN int
2795 SWIG_AsVal_bool (PyObject *obj, bool *val)
2796 {
2797 if (obj == Py_True) {
2798 if (val) *val = true;
2799 return SWIG_OK;
2800 } else if (obj == Py_False) {
2801 if (val) *val = false;
2802 return SWIG_OK;
2803 } else {
2804 long v = 0;
2805 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2806 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2807 return res;
2808 }
2809 }
2810
2811
2812 wxMemorySize wxGetFreeMemory()
2813 { wxPyRaiseNotImplemented(); return 0; }
2814
2815
2816 SWIGINTERN int
2817 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2818 {
2819 long v = 0;
2820 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2821 return SWIG_TypeError;
2822 }
2823 else if (val)
2824 *val = (unsigned long)v;
2825 return SWIG_OK;
2826 }
2827
2828
2829 SWIGINTERNINLINE PyObject*
2830 SWIG_From_unsigned_SS_long (unsigned long value)
2831 {
2832 return (value > LONG_MAX) ?
2833 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2834 }
2835
2836
2837 void* wxGetXDisplay()
2838 {
2839 #ifdef __WXGTK__
2840 return wxGetDisplay();
2841 #else
2842 return NULL;
2843 #endif
2844 }
2845
2846
2847 wxWindow* FindWindowAtPointer() {
2848 wxPoint unused;
2849 return wxFindWindowAtPointer(unused);
2850 }
2851
2852
2853 void wxWakeUpMainThread() {}
2854
2855
2856 bool wxThread_IsMain() {
2857 #ifdef WXP_WITH_THREAD
2858 return wxThread::IsMain();
2859 #else
2860 return true;
2861 #endif
2862 }
2863
2864 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2865 delete self;
2866 }
2867
2868 #include <wx/snglinst.h>
2869
2870
2871 #ifdef __WXMSW__
2872 #include <wx/msw/private.h>
2873 #include <wx/dynload.h>
2874 #endif
2875
2876
2877
2878 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2879 #if 0
2880 , int method
2881 #endif
2882 )
2883 {
2884 #ifdef __WXMSW__
2885 #if 0
2886 switch (method)
2887 {
2888 case 1:
2889 // This one only partially works. Appears to be an undocumented
2890 // "standard" convention that not all widgets adhear to. For
2891 // example, for some widgets backgrounds or non-client areas may
2892 // not be painted.
2893 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2894 break;
2895
2896 case 2:
2897 #endif
2898 // This one works much better, nearly all widgets and their
2899 // children are captured correctly[**]. Prior to the big
2900 // background erase changes that Vadim did in 2004-2005 this
2901 // method failed badly on XP with Themes activated, most native
2902 // widgets draw only partially, if at all. Without themes it
2903 // worked just like on Win2k. After those changes this method
2904 // works very well.
2905 //
2906 // ** For example the radio buttons in a wxRadioBox are not its
2907 // children by default, but you can capture it via the panel
2908 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2909 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2910 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2911 PRF_ERASEBKGND | PRF_OWNED );
2912 return true;
2913 #if 0
2914 break;
2915
2916 case 3:
2917 // This one is only defined in the latest SDK and is only
2918 // available on XP. MSDN says it is similar to sending WM_PRINT
2919 // so I expect that it will work similar to the above. Since it
2920 // is avaialble only on XP, it can't be compiled like this and
2921 // will have to be loaded dynamically.
2922 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2923
2924 // fall through
2925
2926 case 4:
2927 // Use PrintWindow if available, or fallback to WM_PRINT
2928 // otherwise. Unfortunately using PrintWindow is even worse than
2929 // WM_PRINT. For most native widgets nothing is drawn to the dc
2930 // at all, with or without Themes.
2931 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2932 static bool s_triedToLoad = false;
2933 static PrintWindow_t pfnPrintWindow = NULL;
2934 if ( !s_triedToLoad )
2935 {
2936
2937 s_triedToLoad = true;
2938 wxDynamicLibrary dllUser32(_T("user32.dll"));
2939 if ( dllUser32.IsLoaded() )
2940 {
2941 wxLogNull nolog; // Don't report errors here
2942 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2943 }
2944 }
2945 if (pfnPrintWindow)
2946 {
2947 //printf("Using PrintWindow\n");
2948 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2949 }
2950 else
2951 {
2952 //printf("Using WM_PRINT\n");
2953 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2954 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2955 PRF_ERASEBKGND | PRF_OWNED );
2956 }
2957 }
2958 #endif // 0
2959 #else
2960 return false;
2961 #endif // __WXMSW__
2962 }
2963
2964
2965
2966 #include <wx/tipdlg.h>
2967
2968
2969 SWIGINTERNINLINE PyObject *
2970 SWIG_From_size_t (size_t value)
2971 {
2972 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2973 }
2974
2975
2976 class wxPyTipProvider : public wxTipProvider {
2977 public:
2978 wxPyTipProvider(size_t currentTip)
2979 : wxTipProvider(currentTip) {}
2980
2981 DEC_PYCALLBACK_STRING__pure(GetTip);
2982 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2983 PYPRIVATE;
2984 };
2985
2986 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2987 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2988
2989
2990 SWIGINTERNINLINE int
2991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2992 {
2993 unsigned long v;
2994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2996 return res;
2997 }
2998
2999
3000 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3001
3002 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3003
3004 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3005 : wxTimer(owner, id)
3006 {
3007 if (owner == NULL)
3008 SetOwner(this);
3009 }
3010
3011
3012 SWIGINTERN swig_type_info*
3013 SWIG_pchar_descriptor()
3014 {
3015 static int init = 0;
3016 static swig_type_info* info = 0;
3017 if (!init) {
3018 info = SWIG_TypeQuery("_p_char");
3019 init = 1;
3020 }
3021 return info;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3027 {
3028 if (carray) {
3029 if (size > INT_MAX) {
3030 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3031 return pchar_descriptor ?
3032 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3033 } else {
3034 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3035 }
3036 } else {
3037 return SWIG_Py_Void();
3038 }
3039 }
3040
3041
3042 SWIGINTERNINLINE PyObject *
3043 SWIG_FromCharPtr(const char *cptr)
3044 {
3045 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3046 }
3047
3048
3049 SWIGINTERN int
3050 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3051 {
3052 unsigned long v;
3053 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3054 if (SWIG_IsOK(res)) {
3055 if ((v > UINT_MAX)) {
3056 return SWIG_OverflowError;
3057 } else {
3058 if (val) *val = static_cast< unsigned int >(v);
3059 }
3060 }
3061 return res;
3062 }
3063
3064 SWIGINTERN wxString wxLog_TimeStamp(){
3065 wxString msg;
3066 wxLog::TimeStamp(&msg);
3067 return msg;
3068 }
3069 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3070 // Make some wrappers that double any % signs so they are 'escaped'
3071 void wxPyLogFatalError(const wxString& msg)
3072 {
3073 wxString m(msg);
3074 m.Replace(wxT("%"), wxT("%%"));
3075 wxLogFatalError(m);
3076 }
3077
3078 void wxPyLogError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogError(m);
3083 }
3084
3085 void wxPyLogWarning(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogWarning(m);
3090 }
3091
3092 void wxPyLogMessage(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogMessage(m);
3097 }
3098
3099 void wxPyLogInfo(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogInfo(m);
3104 }
3105
3106 void wxPyLogDebug(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogDebug(m);
3111 }
3112
3113 void wxPyLogVerbose(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogVerbose(m);
3118 }
3119
3120 void wxPyLogStatus(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogStatus(m);
3125 }
3126
3127 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(pFrame, m);
3132 }
3133
3134 void wxPyLogSysError(const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogSysError(m);
3139 }
3140
3141 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogGeneric(level, m);
3146 }
3147
3148 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogTrace(mask, m);
3153 }
3154
3155 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162
3163
3164 // A wxLog class that can be derived from in wxPython
3165 class wxPyLog : public wxLog {
3166 public:
3167 wxPyLog() : wxLog() {}
3168
3169 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3170 bool found;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3173 PyObject* s = wx2PyString(szString);
3174 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3175 Py_DECREF(s);
3176 }
3177 wxPyEndBlockThreads(blocked);
3178 if (! found)
3179 wxLog::DoLog(level, szString, t);
3180 }
3181
3182 virtual void DoLogString(const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLogString(szString, t);
3193 }
3194
3195 DEC_PYCALLBACK_VOID_(Flush);
3196 PYPRIVATE;
3197 };
3198 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3199
3200
3201
3202
3203 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3204
3205
3206 #include <wx/joystick.h>
3207
3208
3209 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3210 // A C++ stub class for wxJoystick for platforms that don't have it.
3211 class wxJoystick : public wxObject {
3212 public:
3213 wxJoystick(int joystick = wxJOYSTICK1) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyErr_SetString(PyExc_NotImplementedError,
3216 "wxJoystick is not available on this platform.");
3217 wxPyEndBlockThreads(blocked);
3218 }
3219 wxPoint GetPosition() { return wxPoint(-1,-1); }
3220 int GetZPosition() { return -1; }
3221 int GetButtonState() { return -1; }
3222 int GetPOVPosition() { return -1; }
3223 int GetPOVCTSPosition() { return -1; }
3224 int GetRudderPosition() { return -1; }
3225 int GetUPosition() { return -1; }
3226 int GetVPosition() { return -1; }
3227 int GetMovementThreshold() { return -1; }
3228 void SetMovementThreshold(int threshold) {}
3229
3230 bool IsOk(void) { return false; }
3231 int GetNumberJoysticks() { return -1; }
3232 int GetManufacturerId() { return -1; }
3233 int GetProductId() { return -1; }
3234 wxString GetProductName() { return wxEmptyString; }
3235 int GetXMin() { return -1; }
3236 int GetYMin() { return -1; }
3237 int GetZMin() { return -1; }
3238 int GetXMax() { return -1; }
3239 int GetYMax() { return -1; }
3240 int GetZMax() { return -1; }
3241 int GetNumberButtons() { return -1; }
3242 int GetNumberAxes() { return -1; }
3243 int GetMaxButtons() { return -1; }
3244 int GetMaxAxes() { return -1; }
3245 int GetPollingMin() { return -1; }
3246 int GetPollingMax() { return -1; }
3247 int GetRudderMin() { return -1; }
3248 int GetRudderMax() { return -1; }
3249 int GetUMin() { return -1; }
3250 int GetUMax() { return -1; }
3251 int GetVMin() { return -1; }
3252 int GetVMax() { return -1; }
3253
3254 bool HasRudder() { return false; }
3255 bool HasZ() { return false; }
3256 bool HasU() { return false; }
3257 bool HasV() { return false; }
3258 bool HasPOV() { return false; }
3259 bool HasPOV4Dir() { return false; }
3260 bool HasPOVCTS() { return false; }
3261
3262 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3263 bool ReleaseCapture() { return false; }
3264 };
3265 #endif
3266
3267
3268 #include <wx/sound.h>
3269
3270
3271 #if !wxUSE_SOUND
3272 // A C++ stub class for wxWave for platforms that don't have it.
3273 class wxSound : public wxObject
3274 {
3275 public:
3276 wxSound() {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(const wxString&/*, bool*/) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(int, const wxByte*) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294
3295 ~wxSound() {};
3296
3297 bool Create(const wxString&/*, bool*/) { return false; }
3298 bool Create(int, const wxByte*) { return false; };
3299 bool IsOk() { return false; };
3300 bool Play(unsigned) const { return false; }
3301 static bool Play(const wxString&, unsigned) { return false; }
3302 static void Stop() {}
3303 };
3304
3305 #endif
3306
3307 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3308 if (fileName.Length() == 0)
3309 return new wxSound;
3310 else
3311 return new wxSound(fileName);
3312 }
3313 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3314 unsigned char* buffer; int size;
3315 wxSound *sound = NULL;
3316
3317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3318 if (!PyArg_Parse(data, "t#", &buffer, &size))
3319 goto done;
3320 sound = new wxSound(size, buffer);
3321 done:
3322 wxPyEndBlockThreads(blocked);
3323 return sound;
3324 }
3325 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3326 #ifndef __WXMAC__
3327 unsigned char* buffer;
3328 int size;
3329 bool rv = false;
3330
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 if (!PyArg_Parse(data, "t#", &buffer, &size))
3333 goto done;
3334 rv = self->Create(size, buffer);
3335 done:
3336 wxPyEndBlockThreads(blocked);
3337 return rv;
3338 #else
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 PyErr_SetString(PyExc_NotImplementedError,
3341 "Create from data is not available on this platform.");
3342 wxPyEndBlockThreads(blocked);
3343 return false;
3344 #endif
3345 }
3346
3347 #include <wx/mimetype.h>
3348
3349 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3350 wxString str;
3351 if (self->GetMimeType(&str))
3352 return wx2PyString(str);
3353 else
3354 RETURN_NONE();
3355 }
3356 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3357 wxArrayString arr;
3358 if (self->GetMimeTypes(arr))
3359 return wxArrayString2PyList_helper(arr);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetExtensions(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3371 wxIconLocation loc;
3372 if (self->GetIcon(&loc))
3373 return new wxIcon(loc);
3374 else
3375 return NULL;
3376 }
3377 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc)) {
3380 wxString iconFile = loc.GetFileName();
3381 int iconIndex = -1;
3382
3383
3384
3385 // Make a tuple and put the values in it
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 PyObject* tuple = PyTuple_New(3);
3388 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3389 wxT("wxIcon"), true));
3390 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3391 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3392 wxPyEndBlockThreads(blocked);
3393 return tuple;
3394 }
3395 else
3396 RETURN_NONE();
3397 }
3398 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3399 wxString str;
3400 if (self->GetDescription(&str))
3401 return wx2PyString(str);
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3406 wxString str;
3407 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxArrayString verbs;
3421 wxArrayString commands;
3422 if (self->GetAllCommands(&verbs, &commands,
3423 wxFileType::MessageParameters(filename, mimetype))) {
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 PyObject* tuple = PyTuple_New(2);
3426 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3427 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3428 wxPyEndBlockThreads(blocked);
3429 return tuple;
3430 }
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 return wxFileType::ExpandCommand(command,
3436 wxFileType::MessageParameters(filename, mimetype));
3437 }
3438 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3439 wxArrayString arr;
3440 self->EnumAllFileTypes(arr);
3441 return wxArrayString2PyList_helper(arr);
3442 }
3443
3444 #include <wx/artprov.h>
3445
3446 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3447 static const wxString wxPyART_MENU(wxART_MENU);
3448 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3449 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3450 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3451 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3452 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3453 static const wxString wxPyART_OTHER(wxART_OTHER);
3454 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3455 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3456 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3457 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3458 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3459 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3460 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3461 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3462 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3463 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3464 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3465 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3466 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3467 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3468 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3469 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3470 static const wxString wxPyART_PRINT(wxART_PRINT);
3471 static const wxString wxPyART_HELP(wxART_HELP);
3472 static const wxString wxPyART_TIP(wxART_TIP);
3473 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3474 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3475 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3476 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3477 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3478 static const wxString wxPyART_CDROM(wxART_CDROM);
3479 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3480 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3481 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3482 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3483 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3484 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3485 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3486 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3487 static const wxString wxPyART_ERROR(wxART_ERROR);
3488 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3489 static const wxString wxPyART_WARNING(wxART_WARNING);
3490 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3491 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3492 static const wxString wxPyART_COPY(wxART_COPY);
3493 static const wxString wxPyART_CUT(wxART_CUT);
3494 static const wxString wxPyART_PASTE(wxART_PASTE);
3495 static const wxString wxPyART_DELETE(wxART_DELETE);
3496 static const wxString wxPyART_NEW(wxART_NEW);
3497 static const wxString wxPyART_UNDO(wxART_UNDO);
3498 static const wxString wxPyART_REDO(wxART_REDO);
3499 static const wxString wxPyART_QUIT(wxART_QUIT);
3500 static const wxString wxPyART_FIND(wxART_FIND);
3501 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3502 // Python aware wxArtProvider
3503 class wxPyArtProvider : public wxArtProvider {
3504 public:
3505
3506 virtual wxBitmap CreateBitmap(const wxArtID& id,
3507 const wxArtClient& client,
3508 const wxSize& size) {
3509 wxBitmap rval = wxNullBitmap;
3510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3511 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3512 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3513 PyObject* ro;
3514 wxBitmap* ptr;
3515 PyObject* s1, *s2;
3516 s1 = wx2PyString(id);
3517 s2 = wx2PyString(client);
3518 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3519 Py_DECREF(so);
3520 Py_DECREF(s1);
3521 Py_DECREF(s2);
3522 if (ro) {
3523 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3524 rval = *ptr;
3525 Py_DECREF(ro);
3526 }
3527 }
3528 wxPyEndBlockThreads(blocked);
3529 return rval;
3530 }
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3536
3537
3538
3539 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3540 PyObject* ret = PyTuple_New(3);
3541 if (ret) {
3542 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3543 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3544 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3545 }
3546 return ret;
3547 }
3548
3549 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3550 bool cont;
3551 long index = 0;
3552 wxString value;
3553
3554 cont = self->GetFirstGroup(value, index);
3555 return __EnumerationHelper(cont, value, index);
3556 }
3557 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3558 bool cont;
3559 wxString value;
3560
3561 cont = self->GetNextGroup(value, index);
3562 return __EnumerationHelper(cont, value, index);
3563 }
3564 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3565 bool cont;
3566 long index = 0;
3567 wxString value;
3568
3569 cont = self->GetFirstEntry(value, index);
3570 return __EnumerationHelper(cont, value, index);
3571 }
3572 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3573 bool cont;
3574 wxString value;
3575
3576 cont = self->GetNextEntry(value, index);
3577 return __EnumerationHelper(cont, value, index);
3578 }
3579 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3580 long rv;
3581 self->Read(key, &rv, defaultVal);
3582 return rv;
3583 }
3584
3585 SWIGINTERN int
3586 SWIG_AsVal_double (PyObject *obj, double* val)
3587 {
3588 if (PyNumber_Check(obj)) {
3589 if (val) *val = PyFloat_AsDouble(obj);
3590 return SWIG_OK;
3591 }
3592 return SWIG_TypeError;
3593 }
3594
3595 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3596 double rv;
3597 self->Read(key, &rv, defaultVal);
3598 return rv;
3599 }
3600
3601 #define SWIG_From_double PyFloat_FromDouble
3602
3603 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3604 bool rv;
3605 self->Read(key, &rv, defaultVal);
3606 return rv;
3607 }
3608
3609 #include <wx/datetime.h>
3610
3611 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3612 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3613
3614 #define LOCAL_TZ wxDateTime::Local
3615
3616 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3617 wxString am;
3618 wxString pm;
3619 wxDateTime::GetAmPmStrings(&am, &pm);
3620 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3621 PyObject* tup = PyTuple_New(2);
3622 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3623 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3624 wxPyEndBlockThreads(blocked);
3625 return tup;
3626 }
3627
3628 SWIGINTERNINLINE PyObject *
3629 SWIG_From_unsigned_SS_int (unsigned int value)
3630 {
3631 return SWIG_From_unsigned_SS_long (value);
3632 }
3633
3634 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3635 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3636 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3637 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3638 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3639 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3640 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3641 return (*self < *other);
3642 }
3643 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3645 return (*self <= *other);
3646 }
3647 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3649 return (*self > *other);
3650 }
3651 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3653 return (*self >= *other);
3654 }
3655 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3657 return (*self == *other);
3658 }
3659 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3661 return (*self != *other);
3662 }
3663 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3664 const wxChar* rv;
3665 const wxChar* _date = date;
3666 rv = self->ParseRfc822Date(_date);
3667 if (rv == NULL) return -1;
3668 return rv - _date;
3669 }
3670 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3671 const wxChar* rv;
3672 const wxChar* _date = date;
3673 rv = self->ParseFormat(_date, format, dateDef);
3674 if (rv == NULL) return -1;
3675 return rv - _date;
3676 }
3677 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3678 const wxChar* rv;
3679 const wxChar* _datetime = datetime;
3680 rv = self->ParseDateTime(_datetime);
3681 if (rv == NULL) return -1;
3682 return rv - _datetime;
3683 }
3684 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3685 const wxChar* rv;
3686 const wxChar* _date = date;
3687 rv = self->ParseDate(_date);
3688 if (rv == NULL) return -1;
3689 return rv - _date;
3690 }
3691 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3692 const wxChar* rv;
3693 const wxChar* _time = time;
3694 rv = self->ParseTime(_time);
3695 if (rv == NULL) return -1;
3696 return rv - _time;
3697 }
3698 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3699 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3702 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3703 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3704 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3705 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3706 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3708 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3709 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3710 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3711 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3712 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3713 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3714
3715 #include <wx/dataobj.h>
3716
3717 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3718 size_t count = self->GetFormatCount(dir);
3719 wxDataFormat* formats = new wxDataFormat[count];
3720 self->GetAllFormats(formats, dir);
3721
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724 for (size_t i=0; i<count; i++) {
3725 wxDataFormat* format = new wxDataFormat(formats[i]);
3726 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3727 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3728 }
3729 wxPyEndBlockThreads(blocked);
3730 delete [] formats;
3731 return list;
3732 }
3733 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3734 PyObject* rval = NULL;
3735 size_t size = self->GetDataSize(format);
3736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3737 if (size) {
3738 char* buf = new char[size];
3739 if (self->GetDataHere(format, buf))
3740 rval = PyString_FromStringAndSize(buf, size);
3741 delete [] buf;
3742 }
3743 if (! rval) {
3744 rval = Py_None;
3745 Py_INCREF(rval);
3746 }
3747 wxPyEndBlockThreads(blocked);
3748 return rval;
3749 }
3750 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3751 bool rval;
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 if (PyString_Check(data)) {
3754 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3755 }
3756 else {
3757 // raise a TypeError if not a string
3758 PyErr_SetString(PyExc_TypeError, "String expected.");
3759 rval = false;
3760 }
3761 wxPyEndBlockThreads(blocked);
3762 return rval;
3763 }
3764 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3765 PyObject* rval = NULL;
3766 size_t size = self->GetDataSize();
3767 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3768 if (size) {
3769 char* buf = new char[size];
3770 if (self->GetDataHere(buf))
3771 rval = PyString_FromStringAndSize(buf, size);
3772 delete [] buf;
3773 }
3774 if (! rval) {
3775 rval = Py_None;
3776 Py_INCREF(rval);
3777 }
3778 wxPyEndBlockThreads(blocked);
3779 return rval;
3780 }
3781 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3782 bool rval;
3783 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3784 if (PyString_Check(data)) {
3785 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3786 }
3787 else {
3788 // raise a TypeError if not a string
3789 PyErr_SetString(PyExc_TypeError, "String expected.");
3790 rval = false;
3791 }
3792 wxPyEndBlockThreads(blocked);
3793 return rval;
3794 }
3795 // Create a new class for wxPython to use
3796 class wxPyDataObjectSimple : public wxDataObjectSimple {
3797 public:
3798 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3799 : wxDataObjectSimple(format) {}
3800
3801 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3802 bool GetDataHere(void *buf) const;
3803 bool SetData(size_t len, const void *buf) const;
3804 PYPRIVATE;
3805 };
3806
3807 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3808
3809 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3810 // We need to get the data for this object and write it to buf. I think
3811 // the best way to do this for wxPython is to have the Python method
3812 // return either a string or None and then act appropriately with the
3813 // C++ version.
3814
3815 bool rval = false;
3816 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3817 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3818 PyObject* ro;
3819 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3820 if (ro) {
3821 rval = (ro != Py_None && PyString_Check(ro));
3822 if (rval)
3823 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3824 Py_DECREF(ro);
3825 }
3826 }
3827 wxPyEndBlockThreads(blocked);
3828 return rval;
3829 }
3830
3831 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3832 // For this one we simply need to make a string from buf and len
3833 // and send it to the Python method.
3834 bool rval = false;
3835 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3836 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3837 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3838 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3839 Py_DECREF(data);
3840 }
3841 wxPyEndBlockThreads(blocked);
3842 return rval;
3843 }
3844
3845 // Create a new class for wxPython to use
3846 class wxPyTextDataObject : public wxTextDataObject {
3847 public:
3848 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3849 : wxTextDataObject(text) {}
3850
3851 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3852 DEC_PYCALLBACK_STRING__const(GetText);
3853 DEC_PYCALLBACK__STRING(SetText);
3854 PYPRIVATE;
3855 };
3856
3857 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3858 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3859 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3860
3861
3862 // Create a new class for wxPython to use
3863 class wxPyBitmapDataObject : public wxBitmapDataObject {
3864 public:
3865 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3866 : wxBitmapDataObject(bitmap) {}
3867
3868 wxBitmap GetBitmap() const;
3869 void SetBitmap(const wxBitmap& bitmap);
3870 PYPRIVATE;
3871 };
3872
3873 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3874 wxBitmap* rval = &wxNullBitmap;
3875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3876 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3877 PyObject* ro;
3878 wxBitmap* ptr;
3879 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3880 if (ro) {
3881 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3882 rval = ptr;
3883 Py_DECREF(ro);
3884 }
3885 }
3886 wxPyEndBlockThreads(blocked);
3887 return *rval;
3888 }
3889
3890 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3892 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3893 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3894 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3895 Py_DECREF(bo);
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 }
3899
3900 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3901 return new wxCustomDataObject(wxDataFormat(formatName));
3902 }
3903 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3904 bool rval;
3905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3906 if (PyString_Check(data)) {
3907 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3908 }
3909 else {
3910 // raise a TypeError if not a string
3911 PyErr_SetString(PyExc_TypeError, "String expected.");
3912 rval = false;
3913 }
3914 wxPyEndBlockThreads(blocked);
3915 return rval;
3916 }
3917 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3918 PyObject* obj;
3919 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3920 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3921 wxPyEndBlockThreads(blocked);
3922 return obj;
3923 }
3924
3925 class wxMetafileDataObject : public wxDataObjectSimple
3926 {
3927 public:
3928 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3929 };
3930
3931
3932 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3933
3934
3935 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3938 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3939 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3940
3941
3942 class wxPyTextDropTarget : public wxTextDropTarget {
3943 public:
3944 wxPyTextDropTarget() {}
3945
3946 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3947
3948 DEC_PYCALLBACK__(OnLeave);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3952 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3953
3954 PYPRIVATE;
3955 };
3956
3957 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3958 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3962 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3963
3964
3965
3966 class wxPyFileDropTarget : public wxFileDropTarget {
3967 public:
3968 wxPyFileDropTarget() {}
3969
3970 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3971
3972 DEC_PYCALLBACK__(OnLeave);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3976 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3977
3978 PYPRIVATE;
3979 };
3980
3981 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3982 const wxArrayString& filenames) {
3983 bool rval = false;
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3986 PyObject* list = wxArrayString2PyList_helper(filenames);
3987 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3988 Py_DECREF(list);
3989 }
3990 wxPyEndBlockThreads(blocked);
3991 return rval;
3992 }
3993
3994
3995
3996 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4000 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4001
4002
4003
4004
4005 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4006
4007 #include <wx/display.h>
4008
4009 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4010 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4011
4012 #if !wxUSE_DISPLAY
4013 const wxVideoMode wxDefaultVideoMode;
4014 #endif
4015
4016 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4017 #if wxUSE_DISPLAY
4018 PyObject* pyList = NULL;
4019 wxArrayVideoModes arr = self->GetModes(mode);
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 pyList = PyList_New(0);
4022 for (size_t i=0; i < arr.GetCount(); i++)
4023 {
4024 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4025 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4026 PyList_Append(pyList, pyObj);
4027 Py_DECREF(pyObj);
4028 }
4029 wxPyEndBlockThreads(blocked);
4030 return pyList;
4031 #else
4032 wxPyRaiseNotImplemented();
4033 return NULL;
4034 #endif
4035 }
4036 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4037 #if wxUSE_DISPLAY
4038 return self->GetCurrentMode();
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return wxDefaultVideoMode;
4042 #endif
4043 }
4044 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4045 #if wxUSE_DISPLAY
4046 return self->ChangeMode(mode);
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return false;
4050 #endif
4051 }
4052 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4053 #if wxUSE_DISPLAY
4054 self->ResetMode();
4055 #else
4056 wxPyRaiseNotImplemented();
4057 #endif
4058 }
4059
4060 #include <wx/stdpaths.h>
4061
4062 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4063 return (wxStandardPaths*) &wxStandardPaths::Get();
4064 }
4065 #ifdef __cplusplus
4066 extern "C" {
4067 #endif
4068 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj = 0;
4070 wxSystemColour arg1 ;
4071 wxColour result;
4072 int val1 ;
4073 int ecode1 = 0 ;
4074 PyObject * obj0 = 0 ;
4075 char * kwnames[] = {
4076 (char *) "index", NULL
4077 };
4078
4079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4080 ecode1 = SWIG_AsVal_int(obj0, &val1);
4081 if (!SWIG_IsOK(ecode1)) {
4082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4083 }
4084 arg1 = static_cast< wxSystemColour >(val1);
4085 {
4086 if (!wxPyCheckForApp()) SWIG_fail;
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = wxSystemSettings::GetColour(arg1);
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4093 return resultobj;
4094 fail:
4095 return NULL;
4096 }
4097
4098
4099 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = 0;
4101 wxSystemFont arg1 ;
4102 wxFont result;
4103 int val1 ;
4104 int ecode1 = 0 ;
4105 PyObject * obj0 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "index", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4111 ecode1 = SWIG_AsVal_int(obj0, &val1);
4112 if (!SWIG_IsOK(ecode1)) {
4113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4114 }
4115 arg1 = static_cast< wxSystemFont >(val1);
4116 {
4117 if (!wxPyCheckForApp()) SWIG_fail;
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 result = wxSystemSettings::GetFont(arg1);
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj = 0;
4132 wxSystemMetric arg1 ;
4133 wxWindow *arg2 = (wxWindow *) NULL ;
4134 int result;
4135 int val1 ;
4136 int ecode1 = 0 ;
4137 void *argp2 = 0 ;
4138 int res2 = 0 ;
4139 PyObject * obj0 = 0 ;
4140 PyObject * obj1 = 0 ;
4141 char * kwnames[] = {
4142 (char *) "index",(char *) "win", NULL
4143 };
4144
4145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4146 ecode1 = SWIG_AsVal_int(obj0, &val1);
4147 if (!SWIG_IsOK(ecode1)) {
4148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4149 }
4150 arg1 = static_cast< wxSystemMetric >(val1);
4151 if (obj1) {
4152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4153 if (!SWIG_IsOK(res2)) {
4154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4155 }
4156 arg2 = reinterpret_cast< wxWindow * >(argp2);
4157 }
4158 {
4159 if (!wxPyCheckForApp()) SWIG_fail;
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 resultobj = SWIG_From_int(static_cast< int >(result));
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj = 0;
4174 wxSystemFeature arg1 ;
4175 bool result;
4176 int val1 ;
4177 int ecode1 = 0 ;
4178 PyObject * obj0 = 0 ;
4179 char * kwnames[] = {
4180 (char *) "index", NULL
4181 };
4182
4183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4184 ecode1 = SWIG_AsVal_int(obj0, &val1);
4185 if (!SWIG_IsOK(ecode1)) {
4186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4187 }
4188 arg1 = static_cast< wxSystemFeature >(val1);
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (bool)wxSystemSettings::HasFeature(arg1);
4193 wxPyEndAllowThreads(__tstate);
4194 if (PyErr_Occurred()) SWIG_fail;
4195 }
4196 {
4197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4198 }
4199 return resultobj;
4200 fail:
4201 return NULL;
4202 }
4203
4204
4205 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4206 PyObject *resultobj = 0;
4207 wxSystemScreenType result;
4208
4209 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4210 {
4211 if (!wxPyCheckForApp()) SWIG_fail;
4212 PyThreadState* __tstate = wxPyBeginAllowThreads();
4213 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4214 wxPyEndAllowThreads(__tstate);
4215 if (PyErr_Occurred()) SWIG_fail;
4216 }
4217 resultobj = SWIG_From_int(static_cast< int >(result));
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj = 0;
4226 wxSystemScreenType arg1 ;
4227 int val1 ;
4228 int ecode1 = 0 ;
4229 PyObject * obj0 = 0 ;
4230 char * kwnames[] = {
4231 (char *) "screen", NULL
4232 };
4233
4234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4235 ecode1 = SWIG_AsVal_int(obj0, &val1);
4236 if (!SWIG_IsOK(ecode1)) {
4237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4238 }
4239 arg1 = static_cast< wxSystemScreenType >(val1);
4240 {
4241 if (!wxPyCheckForApp()) SWIG_fail;
4242 PyThreadState* __tstate = wxPyBeginAllowThreads();
4243 wxSystemSettings::SetScreenType(arg1);
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 resultobj = SWIG_Py_Void();
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255 PyObject *obj;
4256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4257 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4258 return SWIG_Py_Void();
4259 }
4260
4261 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4262 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4263 return 1;
4264 }
4265
4266
4267 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4268 PyObject *pyobj = 0;
4269
4270 {
4271 #if wxUSE_UNICODE
4272 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4273 #else
4274 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4275 #endif
4276 }
4277 return pyobj;
4278 }
4279
4280
4281 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4282 PyObject *resultobj = 0;
4283 wxSystemOptions *result = 0 ;
4284
4285 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 result = (wxSystemOptions *)new wxSystemOptions();
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj = 0;
4301 wxString *arg1 = 0 ;
4302 wxString *arg2 = 0 ;
4303 bool temp1 = false ;
4304 bool temp2 = false ;
4305 PyObject * obj0 = 0 ;
4306 PyObject * obj1 = 0 ;
4307 char * kwnames[] = {
4308 (char *) "name",(char *) "value", NULL
4309 };
4310
4311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4312 {
4313 arg1 = wxString_in_helper(obj0);
4314 if (arg1 == NULL) SWIG_fail;
4315 temp1 = true;
4316 }
4317 {
4318 arg2 = wxString_in_helper(obj1);
4319 if (arg2 == NULL) SWIG_fail;
4320 temp2 = true;
4321 }
4322 {
4323 PyThreadState* __tstate = wxPyBeginAllowThreads();
4324 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 resultobj = SWIG_Py_Void();
4329 {
4330 if (temp1)
4331 delete arg1;
4332 }
4333 {
4334 if (temp2)
4335 delete arg2;
4336 }
4337 return resultobj;
4338 fail:
4339 {
4340 if (temp1)
4341 delete arg1;
4342 }
4343 {
4344 if (temp2)
4345 delete arg2;
4346 }
4347 return NULL;
4348 }
4349
4350
4351 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4352 PyObject *resultobj = 0;
4353 wxString *arg1 = 0 ;
4354 int arg2 ;
4355 bool temp1 = false ;
4356 int val2 ;
4357 int ecode2 = 0 ;
4358 PyObject * obj0 = 0 ;
4359 PyObject * obj1 = 0 ;
4360 char * kwnames[] = {
4361 (char *) "name",(char *) "value", NULL
4362 };
4363
4364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4365 {
4366 arg1 = wxString_in_helper(obj0);
4367 if (arg1 == NULL) SWIG_fail;
4368 temp1 = true;
4369 }
4370 ecode2 = SWIG_AsVal_int(obj1, &val2);
4371 if (!SWIG_IsOK(ecode2)) {
4372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4373 }
4374 arg2 = static_cast< int >(val2);
4375 {
4376 PyThreadState* __tstate = wxPyBeginAllowThreads();
4377 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4378 wxPyEndAllowThreads(__tstate);
4379 if (PyErr_Occurred()) SWIG_fail;
4380 }
4381 resultobj = SWIG_Py_Void();
4382 {
4383 if (temp1)
4384 delete arg1;
4385 }
4386 return resultobj;
4387 fail:
4388 {
4389 if (temp1)
4390 delete arg1;
4391 }
4392 return NULL;
4393 }
4394
4395
4396 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj = 0;
4398 wxString *arg1 = 0 ;
4399 wxString result;
4400 bool temp1 = false ;
4401 PyObject * obj0 = 0 ;
4402 char * kwnames[] = {
4403 (char *) "name", NULL
4404 };
4405
4406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4407 {
4408 arg1 = wxString_in_helper(obj0);
4409 if (arg1 == NULL) SWIG_fail;
4410 temp1 = true;
4411 }
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 {
4426 if (temp1)
4427 delete arg1;
4428 }
4429 return resultobj;
4430 fail:
4431 {
4432 if (temp1)
4433 delete arg1;
4434 }
4435 return NULL;
4436 }
4437
4438
4439 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4440 PyObject *resultobj = 0;
4441 wxString *arg1 = 0 ;
4442 int result;
4443 bool temp1 = false ;
4444 PyObject * obj0 = 0 ;
4445 char * kwnames[] = {
4446 (char *) "name", NULL
4447 };
4448
4449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4450 {
4451 arg1 = wxString_in_helper(obj0);
4452 if (arg1 == NULL) SWIG_fail;
4453 temp1 = true;
4454 }
4455 {
4456 PyThreadState* __tstate = wxPyBeginAllowThreads();
4457 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4458 wxPyEndAllowThreads(__tstate);
4459 if (PyErr_Occurred()) SWIG_fail;
4460 }
4461 resultobj = SWIG_From_int(static_cast< int >(result));
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return resultobj;
4467 fail:
4468 {
4469 if (temp1)
4470 delete arg1;
4471 }
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4477 PyObject *resultobj = 0;
4478 wxString *arg1 = 0 ;
4479 bool result;
4480 bool temp1 = false ;
4481 PyObject * obj0 = 0 ;
4482 char * kwnames[] = {
4483 (char *) "name", NULL
4484 };
4485
4486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4487 {
4488 arg1 = wxString_in_helper(obj0);
4489 if (arg1 == NULL) SWIG_fail;
4490 temp1 = true;
4491 }
4492 {
4493 PyThreadState* __tstate = wxPyBeginAllowThreads();
4494 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 {
4499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4500 }
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return resultobj;
4506 fail:
4507 {
4508 if (temp1)
4509 delete arg1;
4510 }
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = 0;
4517 wxString *arg1 = 0 ;
4518 bool result;
4519 bool temp1 = false ;
4520 PyObject * obj0 = 0 ;
4521 char * kwnames[] = {
4522 (char *) "name", NULL
4523 };
4524
4525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4526 {
4527 arg1 = wxString_in_helper(obj0);
4528 if (arg1 == NULL) SWIG_fail;
4529 temp1 = true;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return resultobj;
4545 fail:
4546 {
4547 if (temp1)
4548 delete arg1;
4549 }
4550 return NULL;
4551 }
4552
4553
4554 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *obj;
4556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4557 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4558 return SWIG_Py_Void();
4559 }
4560
4561 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4562 return SWIG_Python_InitShadowInstance(args);
4563 }
4564
4565 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4566 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4567 return 1;
4568 }
4569
4570
4571 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4572 PyObject *pyobj = 0;
4573
4574 {
4575 #if wxUSE_UNICODE
4576 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4577 #else
4578 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4579 #endif
4580 }
4581 return pyobj;
4582 }
4583
4584
4585 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4586 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4587 return 1;
4588 }
4589
4590
4591 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4592 PyObject *pyobj = 0;
4593
4594 {
4595 #if wxUSE_UNICODE
4596 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4597 #else
4598 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4599 #endif
4600 }
4601 return pyobj;
4602 }
4603
4604
4605 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4606 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4607 return 1;
4608 }
4609
4610
4611 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4612 PyObject *pyobj = 0;
4613
4614 {
4615 #if wxUSE_UNICODE
4616 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4617 #else
4618 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4619 #endif
4620 }
4621 return pyobj;
4622 }
4623
4624
4625 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4626 PyObject *resultobj = 0;
4627 long result;
4628
4629 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4630 {
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 result = (long)wxNewId();
4633 wxPyEndAllowThreads(__tstate);
4634 if (PyErr_Occurred()) SWIG_fail;
4635 }
4636 resultobj = SWIG_From_long(static_cast< long >(result));
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4644 PyObject *resultobj = 0;
4645 long arg1 ;
4646 long val1 ;
4647 int ecode1 = 0 ;
4648 PyObject * obj0 = 0 ;
4649 char * kwnames[] = {
4650 (char *) "id", NULL
4651 };
4652
4653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4654 ecode1 = SWIG_AsVal_long(obj0, &val1);
4655 if (!SWIG_IsOK(ecode1)) {
4656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4657 }
4658 arg1 = static_cast< long >(val1);
4659 {
4660 PyThreadState* __tstate = wxPyBeginAllowThreads();
4661 wxRegisterId(arg1);
4662 wxPyEndAllowThreads(__tstate);
4663 if (PyErr_Occurred()) SWIG_fail;
4664 }
4665 resultobj = SWIG_Py_Void();
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673 PyObject *resultobj = 0;
4674 long result;
4675
4676 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 result = (long)wxGetCurrentId();
4680 wxPyEndAllowThreads(__tstate);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 resultobj = SWIG_From_long(static_cast< long >(result));
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 int arg1 ;
4693 bool result;
4694 int val1 ;
4695 int ecode1 = 0 ;
4696 PyObject * obj0 = 0 ;
4697 char * kwnames[] = {
4698 (char *) "id", NULL
4699 };
4700
4701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4702 ecode1 = SWIG_AsVal_int(obj0, &val1);
4703 if (!SWIG_IsOK(ecode1)) {
4704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4705 }
4706 arg1 = static_cast< int >(val1);
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (bool)wxIsStockID(arg1);
4710 wxPyEndAllowThreads(__tstate);
4711 if (PyErr_Occurred()) SWIG_fail;
4712 }
4713 {
4714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4715 }
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 int arg1 ;
4725 wxString *arg2 = 0 ;
4726 bool result;
4727 int val1 ;
4728 int ecode1 = 0 ;
4729 bool temp2 = false ;
4730 PyObject * obj0 = 0 ;
4731 PyObject * obj1 = 0 ;
4732 char * kwnames[] = {
4733 (char *) "id",(char *) "label", NULL
4734 };
4735
4736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4737 ecode1 = SWIG_AsVal_int(obj0, &val1);
4738 if (!SWIG_IsOK(ecode1)) {
4739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4740 }
4741 arg1 = static_cast< int >(val1);
4742 {
4743 arg2 = wxString_in_helper(obj1);
4744 if (arg2 == NULL) SWIG_fail;
4745 temp2 = true;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 {
4754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4755 }
4756 {
4757 if (temp2)
4758 delete arg2;
4759 }
4760 return resultobj;
4761 fail:
4762 {
4763 if (temp2)
4764 delete arg2;
4765 }
4766 return NULL;
4767 }
4768
4769
4770 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4771 PyObject *resultobj = 0;
4772 int arg1 ;
4773 bool arg2 = (bool) true ;
4774 wxString arg3 = (wxString) wxPyEmptyString ;
4775 wxString result;
4776 int val1 ;
4777 int ecode1 = 0 ;
4778 bool val2 ;
4779 int ecode2 = 0 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 PyObject * obj2 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4788 ecode1 = SWIG_AsVal_int(obj0, &val1);
4789 if (!SWIG_IsOK(ecode1)) {
4790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4791 }
4792 arg1 = static_cast< int >(val1);
4793 if (obj1) {
4794 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4795 if (!SWIG_IsOK(ecode2)) {
4796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4797 }
4798 arg2 = static_cast< bool >(val2);
4799 }
4800 if (obj2) {
4801 {
4802 wxString* sptr = wxString_in_helper(obj2);
4803 if (sptr == NULL) SWIG_fail;
4804 arg3 = *sptr;
4805 delete sptr;
4806 }
4807 }
4808 {
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 result = wxGetStockLabel(arg1,arg2,arg3);
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 {
4815 #if wxUSE_UNICODE
4816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4817 #else
4818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4819 #endif
4820 }
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4828 PyObject *resultobj = 0;
4829
4830 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4831 {
4832 if (!wxPyCheckForApp()) SWIG_fail;
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 wxBell();
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847
4848 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4849 {
4850 if (!wxPyCheckForApp()) SWIG_fail;
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 wxEndBusyCursor();
4853 wxPyEndAllowThreads(__tstate);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 resultobj = SWIG_Py_Void();
4857 return resultobj;
4858 fail:
4859 return NULL;
4860 }
4861
4862
4863 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4864 PyObject *resultobj = 0;
4865 bool arg1 = (bool) true ;
4866 long result;
4867 bool val1 ;
4868 int ecode1 = 0 ;
4869 PyObject * obj0 = 0 ;
4870 char * kwnames[] = {
4871 (char *) "resetTimer", NULL
4872 };
4873
4874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4875 if (obj0) {
4876 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4877 if (!SWIG_IsOK(ecode1)) {
4878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4879 }
4880 arg1 = static_cast< bool >(val1);
4881 }
4882 {
4883 PyThreadState* __tstate = wxPyBeginAllowThreads();
4884 result = (long)wxGetElapsedTime(arg1);
4885 wxPyEndAllowThreads(__tstate);
4886 if (PyErr_Occurred()) SWIG_fail;
4887 }
4888 resultobj = SWIG_From_long(static_cast< long >(result));
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896 PyObject *resultobj = 0;
4897 bool result;
4898
4899 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (bool)wxIsBusy();
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 {
4907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4908 }
4909 return resultobj;
4910 fail:
4911 return NULL;
4912 }
4913
4914
4915 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4916 PyObject *resultobj = 0;
4917 wxString result;
4918
4919 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = wxNow();
4923 wxPyEndAllowThreads(__tstate);
4924 if (PyErr_Occurred()) SWIG_fail;
4925 }
4926 {
4927 #if wxUSE_UNICODE
4928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4929 #else
4930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4931 #endif
4932 }
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 wxString const &arg1_defvalue = wxPyEmptyString ;
4942 wxString *arg1 = (wxString *) &arg1_defvalue ;
4943 bool result;
4944 bool temp1 = false ;
4945 PyObject * obj0 = 0 ;
4946 char * kwnames[] = {
4947 (char *) "command", NULL
4948 };
4949
4950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4951 if (obj0) {
4952 {
4953 arg1 = wxString_in_helper(obj0);
4954 if (arg1 == NULL) SWIG_fail;
4955 temp1 = true;
4956 }
4957 }
4958 {
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 result = (bool)wxShell((wxString const &)*arg1);
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 {
4965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4966 }
4967 {
4968 if (temp1)
4969 delete arg1;
4970 }
4971 return resultobj;
4972 fail:
4973 {
4974 if (temp1)
4975 delete arg1;
4976 }
4977 return NULL;
4978 }
4979
4980
4981 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4982 PyObject *resultobj = 0;
4983
4984 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4985 {
4986 PyThreadState* __tstate = wxPyBeginAllowThreads();
4987 wxStartTimer();
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 resultobj = SWIG_Py_Void();
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000 int *arg1 = (int *) 0 ;
5001 int *arg2 = (int *) 0 ;
5002 int result;
5003 int temp1 ;
5004 int res1 = SWIG_TMPOBJ ;
5005 int temp2 ;
5006 int res2 = SWIG_TMPOBJ ;
5007
5008 arg1 = &temp1;
5009 arg2 = &temp2;
5010 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 result = (int)wxGetOsVersion(arg1,arg2);
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_From_int(static_cast< int >(result));
5018 if (SWIG_IsTmpObj(res1)) {
5019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5020 } else {
5021 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5022 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5023 }
5024 if (SWIG_IsTmpObj(res2)) {
5025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5026 } else {
5027 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5029 }
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5037 PyObject *resultobj = 0;
5038 wxString result;
5039
5040 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 result = wxGetOsDescription();
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 {
5048 #if wxUSE_UNICODE
5049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5050 #else
5051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5052 #endif
5053 }
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5061 PyObject *resultobj = 0;
5062 wxMemorySize result;
5063
5064 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5065 {
5066 PyThreadState* __tstate = wxPyBeginAllowThreads();
5067 result = wxGetFreeMemory();
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5079 PyObject *resultobj = 0;
5080 wxShutdownFlags arg1 ;
5081 bool result;
5082 int val1 ;
5083 int ecode1 = 0 ;
5084 PyObject * obj0 = 0 ;
5085 char * kwnames[] = {
5086 (char *) "wFlags", NULL
5087 };
5088
5089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5090 ecode1 = SWIG_AsVal_int(obj0, &val1);
5091 if (!SWIG_IsOK(ecode1)) {
5092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5093 }
5094 arg1 = static_cast< wxShutdownFlags >(val1);
5095 {
5096 if (!wxPyCheckForApp()) SWIG_fail;
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (bool)wxShutdown(arg1);
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 int arg1 ;
5114 int val1 ;
5115 int ecode1 = 0 ;
5116 PyObject * obj0 = 0 ;
5117 char * kwnames[] = {
5118 (char *) "secs", NULL
5119 };
5120
5121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5122 ecode1 = SWIG_AsVal_int(obj0, &val1);
5123 if (!SWIG_IsOK(ecode1)) {
5124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5125 }
5126 arg1 = static_cast< int >(val1);
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 wxSleep(arg1);
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 resultobj = SWIG_Py_Void();
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5141 PyObject *resultobj = 0;
5142 unsigned long arg1 ;
5143 unsigned long val1 ;
5144 int ecode1 = 0 ;
5145 PyObject * obj0 = 0 ;
5146 char * kwnames[] = {
5147 (char *) "milliseconds", NULL
5148 };
5149
5150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5151 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5152 if (!SWIG_IsOK(ecode1)) {
5153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5154 }
5155 arg1 = static_cast< unsigned long >(val1);
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 wxMilliSleep(arg1);
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 resultobj = SWIG_Py_Void();
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj = 0;
5171 unsigned long arg1 ;
5172 unsigned long val1 ;
5173 int ecode1 = 0 ;
5174 PyObject * obj0 = 0 ;
5175 char * kwnames[] = {
5176 (char *) "microseconds", NULL
5177 };
5178
5179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5180 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5181 if (!SWIG_IsOK(ecode1)) {
5182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5183 }
5184 arg1 = static_cast< unsigned long >(val1);
5185 {
5186 PyThreadState* __tstate = wxPyBeginAllowThreads();
5187 wxMicroSleep(arg1);
5188 wxPyEndAllowThreads(__tstate);
5189 if (PyErr_Occurred()) SWIG_fail;
5190 }
5191 resultobj = SWIG_Py_Void();
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5199 PyObject *resultobj = 0;
5200 bool arg1 ;
5201 bool val1 ;
5202 int ecode1 = 0 ;
5203 PyObject * obj0 = 0 ;
5204 char * kwnames[] = {
5205 (char *) "enable", NULL
5206 };
5207
5208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5209 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5210 if (!SWIG_IsOK(ecode1)) {
5211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5212 }
5213 arg1 = static_cast< bool >(val1);
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 wxEnableTopLevelWindows(arg1);
5217 wxPyEndAllowThreads(__tstate);
5218 if (PyErr_Occurred()) SWIG_fail;
5219 }
5220 resultobj = SWIG_Py_Void();
5221 return resultobj;
5222 fail:
5223 return NULL;
5224 }
5225
5226
5227 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5228 PyObject *resultobj = 0;
5229 wxString *arg1 = 0 ;
5230 wxString result;
5231 bool temp1 = false ;
5232 PyObject * obj0 = 0 ;
5233 char * kwnames[] = {
5234 (char *) "_in", NULL
5235 };
5236
5237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5238 {
5239 arg1 = wxString_in_helper(obj0);
5240 if (arg1 == NULL) SWIG_fail;
5241 temp1 = true;
5242 }
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 result = wxStripMenuCodes((wxString const &)*arg1);
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 {
5250 #if wxUSE_UNICODE
5251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5252 #else
5253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5254 #endif
5255 }
5256 {
5257 if (temp1)
5258 delete arg1;
5259 }
5260 return resultobj;
5261 fail:
5262 {
5263 if (temp1)
5264 delete arg1;
5265 }
5266 return NULL;
5267 }
5268
5269
5270 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271 PyObject *resultobj = 0;
5272 wxString result;
5273
5274 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5275 {
5276 PyThreadState* __tstate = wxPyBeginAllowThreads();
5277 result = wxGetEmailAddress();
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 #if wxUSE_UNICODE
5283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5284 #else
5285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5286 #endif
5287 }
5288 return resultobj;
5289 fail:
5290 return NULL;
5291 }
5292
5293
5294 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5295 PyObject *resultobj = 0;
5296 wxString result;
5297
5298 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 result = wxGetHostName();
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 {
5306 #if wxUSE_UNICODE
5307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5308 #else
5309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5310 #endif
5311 }
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5319 PyObject *resultobj = 0;
5320 wxString result;
5321
5322 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5323 {
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = wxGetFullHostName();
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 {
5330 #if wxUSE_UNICODE
5331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5332 #else
5333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5334 #endif
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5343 PyObject *resultobj = 0;
5344 wxString result;
5345
5346 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = wxGetUserId();
5350 wxPyEndAllowThreads(__tstate);
5351 if (PyErr_Occurred()) SWIG_fail;
5352 }
5353 {
5354 #if wxUSE_UNICODE
5355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5356 #else
5357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5358 #endif
5359 }
5360 return resultobj;
5361 fail:
5362 return NULL;
5363 }
5364
5365
5366 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5367 PyObject *resultobj = 0;
5368 wxString result;
5369
5370 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 result = wxGetUserName();
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 {
5378 #if wxUSE_UNICODE
5379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5380 #else
5381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5382 #endif
5383 }
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5391 PyObject *resultobj = 0;
5392 wxString result;
5393
5394 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5395 {
5396 PyThreadState* __tstate = wxPyBeginAllowThreads();
5397 result = wxGetHomeDir();
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 #if wxUSE_UNICODE
5403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5404 #else
5405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5406 #endif
5407 }
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj = 0;
5416 wxString const &arg1_defvalue = wxPyEmptyString ;
5417 wxString *arg1 = (wxString *) &arg1_defvalue ;
5418 wxString result;
5419 bool temp1 = false ;
5420 PyObject * obj0 = 0 ;
5421 char * kwnames[] = {
5422 (char *) "user", NULL
5423 };
5424
5425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5426 if (obj0) {
5427 {
5428 arg1 = wxString_in_helper(obj0);
5429 if (arg1 == NULL) SWIG_fail;
5430 temp1 = true;
5431 }
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = wxGetUserHome((wxString const &)*arg1);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 #if wxUSE_UNICODE
5441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5442 #else
5443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5444 #endif
5445 }
5446 {
5447 if (temp1)
5448 delete arg1;
5449 }
5450 return resultobj;
5451 fail:
5452 {
5453 if (temp1)
5454 delete arg1;
5455 }
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 unsigned long result;
5463
5464 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (unsigned long)wxGetProcessId();
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *resultobj = 0;
5480
5481 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5482 {
5483 PyThreadState* __tstate = wxPyBeginAllowThreads();
5484 wxTrap();
5485 wxPyEndAllowThreads(__tstate);
5486 if (PyErr_Occurred()) SWIG_fail;
5487 }
5488 resultobj = SWIG_Py_Void();
5489 return resultobj;
5490 fail:
5491 return NULL;
5492 }
5493
5494
5495 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5496 PyObject *resultobj = 0;
5497 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5498 wxString *arg1 = (wxString *) &arg1_defvalue ;
5499 wxString const &arg2_defvalue = wxPyEmptyString ;
5500 wxString *arg2 = (wxString *) &arg2_defvalue ;
5501 wxString const &arg3_defvalue = wxPyEmptyString ;
5502 wxString *arg3 = (wxString *) &arg3_defvalue ;
5503 wxString const &arg4_defvalue = wxPyEmptyString ;
5504 wxString *arg4 = (wxString *) &arg4_defvalue ;
5505 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5506 wxString *arg5 = (wxString *) &arg5_defvalue ;
5507 int arg6 = (int) 0 ;
5508 wxWindow *arg7 = (wxWindow *) NULL ;
5509 int arg8 = (int) -1 ;
5510 int arg9 = (int) -1 ;
5511 wxString result;
5512 bool temp1 = false ;
5513 bool temp2 = false ;
5514 bool temp3 = false ;
5515 bool temp4 = false ;
5516 bool temp5 = false ;
5517 int val6 ;
5518 int ecode6 = 0 ;
5519 void *argp7 = 0 ;
5520 int res7 = 0 ;
5521 int val8 ;
5522 int ecode8 = 0 ;
5523 int val9 ;
5524 int ecode9 = 0 ;
5525 PyObject * obj0 = 0 ;
5526 PyObject * obj1 = 0 ;
5527 PyObject * obj2 = 0 ;
5528 PyObject * obj3 = 0 ;
5529 PyObject * obj4 = 0 ;
5530 PyObject * obj5 = 0 ;
5531 PyObject * obj6 = 0 ;
5532 PyObject * obj7 = 0 ;
5533 PyObject * obj8 = 0 ;
5534 char * kwnames[] = {
5535 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5536 };
5537
5538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5539 if (obj0) {
5540 {
5541 arg1 = wxString_in_helper(obj0);
5542 if (arg1 == NULL) SWIG_fail;
5543 temp1 = true;
5544 }
5545 }
5546 if (obj1) {
5547 {
5548 arg2 = wxString_in_helper(obj1);
5549 if (arg2 == NULL) SWIG_fail;
5550 temp2 = true;
5551 }
5552 }
5553 if (obj2) {
5554 {
5555 arg3 = wxString_in_helper(obj2);
5556 if (arg3 == NULL) SWIG_fail;
5557 temp3 = true;
5558 }
5559 }
5560 if (obj3) {
5561 {
5562 arg4 = wxString_in_helper(obj3);
5563 if (arg4 == NULL) SWIG_fail;
5564 temp4 = true;
5565 }
5566 }
5567 if (obj4) {
5568 {
5569 arg5 = wxString_in_helper(obj4);
5570 if (arg5 == NULL) SWIG_fail;
5571 temp5 = true;
5572 }
5573 }
5574 if (obj5) {
5575 ecode6 = SWIG_AsVal_int(obj5, &val6);
5576 if (!SWIG_IsOK(ecode6)) {
5577 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5578 }
5579 arg6 = static_cast< int >(val6);
5580 }
5581 if (obj6) {
5582 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5583 if (!SWIG_IsOK(res7)) {
5584 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5585 }
5586 arg7 = reinterpret_cast< wxWindow * >(argp7);
5587 }
5588 if (obj7) {
5589 ecode8 = SWIG_AsVal_int(obj7, &val8);
5590 if (!SWIG_IsOK(ecode8)) {
5591 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5592 }
5593 arg8 = static_cast< int >(val8);
5594 }
5595 if (obj8) {
5596 ecode9 = SWIG_AsVal_int(obj8, &val9);
5597 if (!SWIG_IsOK(ecode9)) {
5598 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5599 }
5600 arg9 = static_cast< int >(val9);
5601 }
5602 {
5603 if (!wxPyCheckForApp()) SWIG_fail;
5604 PyThreadState* __tstate = wxPyBeginAllowThreads();
5605 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5606 wxPyEndAllowThreads(__tstate);
5607 if (PyErr_Occurred()) SWIG_fail;
5608 }
5609 {
5610 #if wxUSE_UNICODE
5611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5612 #else
5613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5614 #endif
5615 }
5616 {
5617 if (temp1)
5618 delete arg1;
5619 }
5620 {
5621 if (temp2)
5622 delete arg2;
5623 }
5624 {
5625 if (temp3)
5626 delete arg3;
5627 }
5628 {
5629 if (temp4)
5630 delete arg4;
5631 }
5632 {
5633 if (temp5)
5634 delete arg5;
5635 }
5636 return resultobj;
5637 fail:
5638 {
5639 if (temp1)
5640 delete arg1;
5641 }
5642 {
5643 if (temp2)
5644 delete arg2;
5645 }
5646 {
5647 if (temp3)
5648 delete arg3;
5649 }
5650 {
5651 if (temp4)
5652 delete arg4;
5653 }
5654 {
5655 if (temp5)
5656 delete arg5;
5657 }
5658 return NULL;
5659 }
5660
5661
5662 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5663 PyObject *resultobj = 0;
5664 wxString *arg1 = 0 ;
5665 wxString *arg2 = 0 ;
5666 wxString const &arg3_defvalue = wxPyEmptyString ;
5667 wxString *arg3 = (wxString *) &arg3_defvalue ;
5668 wxWindow *arg4 = (wxWindow *) NULL ;
5669 wxString result;
5670 bool temp1 = false ;
5671 bool temp2 = false ;
5672 bool temp3 = false ;
5673 void *argp4 = 0 ;
5674 int res4 = 0 ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 PyObject * obj2 = 0 ;
5678 PyObject * obj3 = 0 ;
5679 char * kwnames[] = {
5680 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5681 };
5682
5683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5684 {
5685 arg1 = wxString_in_helper(obj0);
5686 if (arg1 == NULL) SWIG_fail;
5687 temp1 = true;
5688 }
5689 {
5690 arg2 = wxString_in_helper(obj1);
5691 if (arg2 == NULL) SWIG_fail;
5692 temp2 = true;
5693 }
5694 if (obj2) {
5695 {
5696 arg3 = wxString_in_helper(obj2);
5697 if (arg3 == NULL) SWIG_fail;
5698 temp3 = true;
5699 }
5700 }
5701 if (obj3) {
5702 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5703 if (!SWIG_IsOK(res4)) {
5704 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5705 }
5706 arg4 = reinterpret_cast< wxWindow * >(argp4);
5707 }
5708 {
5709 if (!wxPyCheckForApp()) SWIG_fail;
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 {
5716 #if wxUSE_UNICODE
5717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5718 #else
5719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5720 #endif
5721 }
5722 {
5723 if (temp1)
5724 delete arg1;
5725 }
5726 {
5727 if (temp2)
5728 delete arg2;
5729 }
5730 {
5731 if (temp3)
5732 delete arg3;
5733 }
5734 return resultobj;
5735 fail:
5736 {
5737 if (temp1)
5738 delete arg1;
5739 }
5740 {
5741 if (temp2)
5742 delete arg2;
5743 }
5744 {
5745 if (temp3)
5746 delete arg3;
5747 }
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = 0;
5754 wxString *arg1 = 0 ;
5755 wxString *arg2 = 0 ;
5756 wxString const &arg3_defvalue = wxPyEmptyString ;
5757 wxString *arg3 = (wxString *) &arg3_defvalue ;
5758 wxWindow *arg4 = (wxWindow *) NULL ;
5759 wxString result;
5760 bool temp1 = false ;
5761 bool temp2 = false ;
5762 bool temp3 = false ;
5763 void *argp4 = 0 ;
5764 int res4 = 0 ;
5765 PyObject * obj0 = 0 ;
5766 PyObject * obj1 = 0 ;
5767 PyObject * obj2 = 0 ;
5768 PyObject * obj3 = 0 ;
5769 char * kwnames[] = {
5770 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5771 };
5772
5773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5774 {
5775 arg1 = wxString_in_helper(obj0);
5776 if (arg1 == NULL) SWIG_fail;
5777 temp1 = true;
5778 }
5779 {
5780 arg2 = wxString_in_helper(obj1);
5781 if (arg2 == NULL) SWIG_fail;
5782 temp2 = true;
5783 }
5784 if (obj2) {
5785 {
5786 arg3 = wxString_in_helper(obj2);
5787 if (arg3 == NULL) SWIG_fail;
5788 temp3 = true;
5789 }
5790 }
5791 if (obj3) {
5792 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5793 if (!SWIG_IsOK(res4)) {
5794 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5795 }
5796 arg4 = reinterpret_cast< wxWindow * >(argp4);
5797 }
5798 {
5799 if (!wxPyCheckForApp()) SWIG_fail;
5800 PyThreadState* __tstate = wxPyBeginAllowThreads();
5801 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 #if wxUSE_UNICODE
5807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5808 #else
5809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5810 #endif
5811 }
5812 {
5813 if (temp1)
5814 delete arg1;
5815 }
5816 {
5817 if (temp2)
5818 delete arg2;
5819 }
5820 {
5821 if (temp3)
5822 delete arg3;
5823 }
5824 return resultobj;
5825 fail:
5826 {
5827 if (temp1)
5828 delete arg1;
5829 }
5830 {
5831 if (temp2)
5832 delete arg2;
5833 }
5834 {
5835 if (temp3)
5836 delete arg3;
5837 }
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5845 wxString *arg1 = (wxString *) &arg1_defvalue ;
5846 wxString const &arg2_defvalue = wxPyEmptyString ;
5847 wxString *arg2 = (wxString *) &arg2_defvalue ;
5848 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5849 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5850 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5851 wxWindow *arg5 = (wxWindow *) NULL ;
5852 wxString result;
5853 bool temp1 = false ;
5854 bool temp2 = false ;
5855 long val3 ;
5856 int ecode3 = 0 ;
5857 wxPoint temp4 ;
5858 void *argp5 = 0 ;
5859 int res5 = 0 ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 PyObject * obj2 = 0 ;
5863 PyObject * obj3 = 0 ;
5864 PyObject * obj4 = 0 ;
5865 char * kwnames[] = {
5866 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5867 };
5868
5869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5870 if (obj0) {
5871 {
5872 arg1 = wxString_in_helper(obj0);
5873 if (arg1 == NULL) SWIG_fail;
5874 temp1 = true;
5875 }
5876 }
5877 if (obj1) {
5878 {
5879 arg2 = wxString_in_helper(obj1);
5880 if (arg2 == NULL) SWIG_fail;
5881 temp2 = true;
5882 }
5883 }
5884 if (obj2) {
5885 ecode3 = SWIG_AsVal_long(obj2, &val3);
5886 if (!SWIG_IsOK(ecode3)) {
5887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5888 }
5889 arg3 = static_cast< long >(val3);
5890 }
5891 if (obj3) {
5892 {
5893 arg4 = &temp4;
5894 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5895 }
5896 }
5897 if (obj4) {
5898 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5899 if (!SWIG_IsOK(res5)) {
5900 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5901 }
5902 arg5 = reinterpret_cast< wxWindow * >(argp5);
5903 }
5904 {
5905 if (!wxPyCheckForApp()) SWIG_fail;
5906 PyThreadState* __tstate = wxPyBeginAllowThreads();
5907 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 {
5912 #if wxUSE_UNICODE
5913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5914 #else
5915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5916 #endif
5917 }
5918 {
5919 if (temp1)
5920 delete arg1;
5921 }
5922 {
5923 if (temp2)
5924 delete arg2;
5925 }
5926 return resultobj;
5927 fail:
5928 {
5929 if (temp1)
5930 delete arg1;
5931 }
5932 {
5933 if (temp2)
5934 delete arg2;
5935 }
5936 return NULL;
5937 }
5938
5939
5940 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = 0;
5942 wxString *arg1 = 0 ;
5943 wxString const &arg2_defvalue = wxPyEmptyString ;
5944 wxString *arg2 = (wxString *) &arg2_defvalue ;
5945 wxString const &arg3_defvalue = wxPyEmptyString ;
5946 wxString *arg3 = (wxString *) &arg3_defvalue ;
5947 wxWindow *arg4 = (wxWindow *) NULL ;
5948 int arg5 = (int) -1 ;
5949 int arg6 = (int) -1 ;
5950 bool arg7 = (bool) true ;
5951 wxString result;
5952 bool temp1 = false ;
5953 bool temp2 = false ;
5954 bool temp3 = false ;
5955 void *argp4 = 0 ;
5956 int res4 = 0 ;
5957 int val5 ;
5958 int ecode5 = 0 ;
5959 int val6 ;
5960 int ecode6 = 0 ;
5961 bool val7 ;
5962 int ecode7 = 0 ;
5963 PyObject * obj0 = 0 ;
5964 PyObject * obj1 = 0 ;
5965 PyObject * obj2 = 0 ;
5966 PyObject * obj3 = 0 ;
5967 PyObject * obj4 = 0 ;
5968 PyObject * obj5 = 0 ;
5969 PyObject * obj6 = 0 ;
5970 char * kwnames[] = {
5971 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5972 };
5973
5974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5975 {
5976 arg1 = wxString_in_helper(obj0);
5977 if (arg1 == NULL) SWIG_fail;
5978 temp1 = true;
5979 }
5980 if (obj1) {
5981 {
5982 arg2 = wxString_in_helper(obj1);
5983 if (arg2 == NULL) SWIG_fail;
5984 temp2 = true;
5985 }
5986 }
5987 if (obj2) {
5988 {
5989 arg3 = wxString_in_helper(obj2);
5990 if (arg3 == NULL) SWIG_fail;
5991 temp3 = true;
5992 }
5993 }
5994 if (obj3) {
5995 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5996 if (!SWIG_IsOK(res4)) {
5997 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
5998 }
5999 arg4 = reinterpret_cast< wxWindow * >(argp4);
6000 }
6001 if (obj4) {
6002 ecode5 = SWIG_AsVal_int(obj4, &val5);
6003 if (!SWIG_IsOK(ecode5)) {
6004 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6005 }
6006 arg5 = static_cast< int >(val5);
6007 }
6008 if (obj5) {
6009 ecode6 = SWIG_AsVal_int(obj5, &val6);
6010 if (!SWIG_IsOK(ecode6)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6012 }
6013 arg6 = static_cast< int >(val6);
6014 }
6015 if (obj6) {
6016 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6017 if (!SWIG_IsOK(ecode7)) {
6018 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6019 }
6020 arg7 = static_cast< bool >(val7);
6021 }
6022 {
6023 if (!wxPyCheckForApp()) SWIG_fail;
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 #if wxUSE_UNICODE
6031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6032 #else
6033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6034 #endif
6035 }
6036 {
6037 if (temp1)
6038 delete arg1;
6039 }
6040 {
6041 if (temp2)
6042 delete arg2;
6043 }
6044 {
6045 if (temp3)
6046 delete arg3;
6047 }
6048 return resultobj;
6049 fail:
6050 {
6051 if (temp1)
6052 delete arg1;
6053 }
6054 {
6055 if (temp2)
6056 delete arg2;
6057 }
6058 {
6059 if (temp3)
6060 delete arg3;
6061 }
6062 return NULL;
6063 }
6064
6065
6066 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj = 0;
6068 wxString *arg1 = 0 ;
6069 wxString const &arg2_defvalue = wxPyEmptyString ;
6070 wxString *arg2 = (wxString *) &arg2_defvalue ;
6071 wxString const &arg3_defvalue = wxPyEmptyString ;
6072 wxString *arg3 = (wxString *) &arg3_defvalue ;
6073 wxWindow *arg4 = (wxWindow *) NULL ;
6074 wxString result;
6075 bool temp1 = false ;
6076 bool temp2 = false ;
6077 bool temp3 = false ;
6078 void *argp4 = 0 ;
6079 int res4 = 0 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 PyObject * obj2 = 0 ;
6083 PyObject * obj3 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6089 {
6090 arg1 = wxString_in_helper(obj0);
6091 if (arg1 == NULL) SWIG_fail;
6092 temp1 = true;
6093 }
6094 if (obj1) {
6095 {
6096 arg2 = wxString_in_helper(obj1);
6097 if (arg2 == NULL) SWIG_fail;
6098 temp2 = true;
6099 }
6100 }
6101 if (obj2) {
6102 {
6103 arg3 = wxString_in_helper(obj2);
6104 if (arg3 == NULL) SWIG_fail;
6105 temp3 = true;
6106 }
6107 }
6108 if (obj3) {
6109 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6110 if (!SWIG_IsOK(res4)) {
6111 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6112 }
6113 arg4 = reinterpret_cast< wxWindow * >(argp4);
6114 }
6115 {
6116 if (!wxPyCheckForApp()) SWIG_fail;
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6119 wxPyEndAllowThreads(__tstate);
6120 if (PyErr_Occurred()) SWIG_fail;
6121 }
6122 {
6123 #if wxUSE_UNICODE
6124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6125 #else
6126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6127 #endif
6128 }
6129 {
6130 if (temp1)
6131 delete arg1;
6132 }
6133 {
6134 if (temp2)
6135 delete arg2;
6136 }
6137 {
6138 if (temp3)
6139 delete arg3;
6140 }
6141 return resultobj;
6142 fail:
6143 {
6144 if (temp1)
6145 delete arg1;
6146 }
6147 {
6148 if (temp2)
6149 delete arg2;
6150 }
6151 {
6152 if (temp3)
6153 delete arg3;
6154 }
6155 return NULL;
6156 }
6157
6158
6159 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj = 0;
6161 wxString *arg1 = 0 ;
6162 wxString *arg2 = 0 ;
6163 int arg3 ;
6164 wxString *arg4 = (wxString *) 0 ;
6165 wxWindow *arg5 = (wxWindow *) NULL ;
6166 int arg6 = (int) -1 ;
6167 int arg7 = (int) -1 ;
6168 bool arg8 = (bool) true ;
6169 int arg9 = (int) 150 ;
6170 int arg10 = (int) 200 ;
6171 wxString result;
6172 bool temp1 = false ;
6173 bool temp2 = false ;
6174 void *argp5 = 0 ;
6175 int res5 = 0 ;
6176 int val6 ;
6177 int ecode6 = 0 ;
6178 int val7 ;
6179 int ecode7 = 0 ;
6180 bool val8 ;
6181 int ecode8 = 0 ;
6182 int val9 ;
6183 int ecode9 = 0 ;
6184 int val10 ;
6185 int ecode10 = 0 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 PyObject * obj2 = 0 ;
6189 PyObject * obj3 = 0 ;
6190 PyObject * obj4 = 0 ;
6191 PyObject * obj5 = 0 ;
6192 PyObject * obj6 = 0 ;
6193 PyObject * obj7 = 0 ;
6194 PyObject * obj8 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6200 {
6201 arg1 = wxString_in_helper(obj0);
6202 if (arg1 == NULL) SWIG_fail;
6203 temp1 = true;
6204 }
6205 {
6206 arg2 = wxString_in_helper(obj1);
6207 if (arg2 == NULL) SWIG_fail;
6208 temp2 = true;
6209 }
6210 {
6211 arg3 = PyList_Size(obj2);
6212 arg4 = wxString_LIST_helper(obj2);
6213 if (arg4 == NULL) SWIG_fail;
6214 }
6215 if (obj3) {
6216 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6217 if (!SWIG_IsOK(res5)) {
6218 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6219 }
6220 arg5 = reinterpret_cast< wxWindow * >(argp5);
6221 }
6222 if (obj4) {
6223 ecode6 = SWIG_AsVal_int(obj4, &val6);
6224 if (!SWIG_IsOK(ecode6)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6226 }
6227 arg6 = static_cast< int >(val6);
6228 }
6229 if (obj5) {
6230 ecode7 = SWIG_AsVal_int(obj5, &val7);
6231 if (!SWIG_IsOK(ecode7)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6233 }
6234 arg7 = static_cast< int >(val7);
6235 }
6236 if (obj6) {
6237 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6238 if (!SWIG_IsOK(ecode8)) {
6239 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6240 }
6241 arg8 = static_cast< bool >(val8);
6242 }
6243 if (obj7) {
6244 ecode9 = SWIG_AsVal_int(obj7, &val9);
6245 if (!SWIG_IsOK(ecode9)) {
6246 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6247 }
6248 arg9 = static_cast< int >(val9);
6249 }
6250 if (obj8) {
6251 ecode10 = SWIG_AsVal_int(obj8, &val10);
6252 if (!SWIG_IsOK(ecode10)) {
6253 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6254 }
6255 arg10 = static_cast< int >(val10);
6256 }
6257 {
6258 if (!wxPyCheckForApp()) SWIG_fail;
6259 PyThreadState* __tstate = wxPyBeginAllowThreads();
6260 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 {
6265 #if wxUSE_UNICODE
6266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6267 #else
6268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6269 #endif
6270 }
6271 {
6272 if (temp1)
6273 delete arg1;
6274 }
6275 {
6276 if (temp2)
6277 delete arg2;
6278 }
6279 {
6280 if (arg4) delete [] arg4;
6281 }
6282 return resultobj;
6283 fail:
6284 {
6285 if (temp1)
6286 delete arg1;
6287 }
6288 {
6289 if (temp2)
6290 delete arg2;
6291 }
6292 {
6293 if (arg4) delete [] arg4;
6294 }
6295 return NULL;
6296 }
6297
6298
6299 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj = 0;
6301 wxString *arg1 = 0 ;
6302 wxString *arg2 = 0 ;
6303 int arg3 ;
6304 wxString *arg4 = (wxString *) 0 ;
6305 wxWindow *arg5 = (wxWindow *) NULL ;
6306 int arg6 = (int) -1 ;
6307 int arg7 = (int) -1 ;
6308 bool arg8 = (bool) true ;
6309 int arg9 = (int) 150 ;
6310 int arg10 = (int) 200 ;
6311 int result;
6312 bool temp1 = false ;
6313 bool temp2 = false ;
6314 void *argp5 = 0 ;
6315 int res5 = 0 ;
6316 int val6 ;
6317 int ecode6 = 0 ;
6318 int val7 ;
6319 int ecode7 = 0 ;
6320 bool val8 ;
6321 int ecode8 = 0 ;
6322 int val9 ;
6323 int ecode9 = 0 ;
6324 int val10 ;
6325 int ecode10 = 0 ;
6326 PyObject * obj0 = 0 ;
6327 PyObject * obj1 = 0 ;
6328 PyObject * obj2 = 0 ;
6329 PyObject * obj3 = 0 ;
6330 PyObject * obj4 = 0 ;
6331 PyObject * obj5 = 0 ;
6332 PyObject * obj6 = 0 ;
6333 PyObject * obj7 = 0 ;
6334 PyObject * obj8 = 0 ;
6335 char * kwnames[] = {
6336 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6337 };
6338
6339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6340 {
6341 arg1 = wxString_in_helper(obj0);
6342 if (arg1 == NULL) SWIG_fail;
6343 temp1 = true;
6344 }
6345 {
6346 arg2 = wxString_in_helper(obj1);
6347 if (arg2 == NULL) SWIG_fail;
6348 temp2 = true;
6349 }
6350 {
6351 arg3 = PyList_Size(obj2);
6352 arg4 = wxString_LIST_helper(obj2);
6353 if (arg4 == NULL) SWIG_fail;
6354 }
6355 if (obj3) {
6356 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6357 if (!SWIG_IsOK(res5)) {
6358 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6359 }
6360 arg5 = reinterpret_cast< wxWindow * >(argp5);
6361 }
6362 if (obj4) {
6363 ecode6 = SWIG_AsVal_int(obj4, &val6);
6364 if (!SWIG_IsOK(ecode6)) {
6365 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6366 }
6367 arg6 = static_cast< int >(val6);
6368 }
6369 if (obj5) {
6370 ecode7 = SWIG_AsVal_int(obj5, &val7);
6371 if (!SWIG_IsOK(ecode7)) {
6372 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6373 }
6374 arg7 = static_cast< int >(val7);
6375 }
6376 if (obj6) {
6377 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6378 if (!SWIG_IsOK(ecode8)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6380 }
6381 arg8 = static_cast< bool >(val8);
6382 }
6383 if (obj7) {
6384 ecode9 = SWIG_AsVal_int(obj7, &val9);
6385 if (!SWIG_IsOK(ecode9)) {
6386 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6387 }
6388 arg9 = static_cast< int >(val9);
6389 }
6390 if (obj8) {
6391 ecode10 = SWIG_AsVal_int(obj8, &val10);
6392 if (!SWIG_IsOK(ecode10)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6394 }
6395 arg10 = static_cast< int >(val10);
6396 }
6397 {
6398 if (!wxPyCheckForApp()) SWIG_fail;
6399 PyThreadState* __tstate = wxPyBeginAllowThreads();
6400 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 resultobj = SWIG_From_int(static_cast< int >(result));
6405 {
6406 if (temp1)
6407 delete arg1;
6408 }
6409 {
6410 if (temp2)
6411 delete arg2;
6412 }
6413 {
6414 if (arg4) delete [] arg4;
6415 }
6416 return resultobj;
6417 fail:
6418 {
6419 if (temp1)
6420 delete arg1;
6421 }
6422 {
6423 if (temp2)
6424 delete arg2;
6425 }
6426 {
6427 if (arg4) delete [] arg4;
6428 }
6429 return NULL;
6430 }
6431
6432
6433 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = 0;
6435 wxString *arg1 = 0 ;
6436 wxString const &arg2_defvalue = wxPyEmptyString ;
6437 wxString *arg2 = (wxString *) &arg2_defvalue ;
6438 int arg3 = (int) wxOK|wxCENTRE ;
6439 wxWindow *arg4 = (wxWindow *) NULL ;
6440 int arg5 = (int) -1 ;
6441 int arg6 = (int) -1 ;
6442 int result;
6443 bool temp1 = false ;
6444 bool temp2 = false ;
6445 int val3 ;
6446 int ecode3 = 0 ;
6447 void *argp4 = 0 ;
6448 int res4 = 0 ;
6449 int val5 ;
6450 int ecode5 = 0 ;
6451 int val6 ;
6452 int ecode6 = 0 ;
6453 PyObject * obj0 = 0 ;
6454 PyObject * obj1 = 0 ;
6455 PyObject * obj2 = 0 ;
6456 PyObject * obj3 = 0 ;
6457 PyObject * obj4 = 0 ;
6458 PyObject * obj5 = 0 ;
6459 char * kwnames[] = {
6460 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6461 };
6462
6463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6464 {
6465 arg1 = wxString_in_helper(obj0);
6466 if (arg1 == NULL) SWIG_fail;
6467 temp1 = true;
6468 }
6469 if (obj1) {
6470 {
6471 arg2 = wxString_in_helper(obj1);
6472 if (arg2 == NULL) SWIG_fail;
6473 temp2 = true;
6474 }
6475 }
6476 if (obj2) {
6477 ecode3 = SWIG_AsVal_int(obj2, &val3);
6478 if (!SWIG_IsOK(ecode3)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6480 }
6481 arg3 = static_cast< int >(val3);
6482 }
6483 if (obj3) {
6484 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6485 if (!SWIG_IsOK(res4)) {
6486 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6487 }
6488 arg4 = reinterpret_cast< wxWindow * >(argp4);
6489 }
6490 if (obj4) {
6491 ecode5 = SWIG_AsVal_int(obj4, &val5);
6492 if (!SWIG_IsOK(ecode5)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6494 }
6495 arg5 = static_cast< int >(val5);
6496 }
6497 if (obj5) {
6498 ecode6 = SWIG_AsVal_int(obj5, &val6);
6499 if (!SWIG_IsOK(ecode6)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6501 }
6502 arg6 = static_cast< int >(val6);
6503 }
6504 {
6505 if (!wxPyCheckForApp()) SWIG_fail;
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 {
6513 if (temp1)
6514 delete arg1;
6515 }
6516 {
6517 if (temp2)
6518 delete arg2;
6519 }
6520 return resultobj;
6521 fail:
6522 {
6523 if (temp1)
6524 delete arg1;
6525 }
6526 {
6527 if (temp2)
6528 delete arg2;
6529 }
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6535 PyObject *resultobj = 0;
6536 bool result;
6537
6538 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6539 {
6540 if (!wxPyCheckForApp()) SWIG_fail;
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 result = (bool)wxColourDisplay();
6543 wxPyEndAllowThreads(__tstate);
6544 if (PyErr_Occurred()) SWIG_fail;
6545 }
6546 {
6547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6548 }
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6556 PyObject *resultobj = 0;
6557 int result;
6558
6559 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6560 {
6561 if (!wxPyCheckForApp()) SWIG_fail;
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 result = (int)wxDisplayDepth();
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_From_int(static_cast< int >(result));
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 int result;
6577
6578 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6579 {
6580 if (!wxPyCheckForApp()) SWIG_fail;
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 result = (int)wxGetDisplayDepth();
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_From_int(static_cast< int >(result));
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 int *arg1 = (int *) 0 ;
6596 int *arg2 = (int *) 0 ;
6597 int temp1 ;
6598 int res1 = SWIG_TMPOBJ ;
6599 int temp2 ;
6600 int res2 = SWIG_TMPOBJ ;
6601
6602 arg1 = &temp1;
6603 arg2 = &temp2;
6604 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6605 {
6606 if (!wxPyCheckForApp()) SWIG_fail;
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 wxDisplaySize(arg1,arg2);
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_Py_Void();
6613 if (SWIG_IsTmpObj(res1)) {
6614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6615 } else {
6616 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6618 }
6619 if (SWIG_IsTmpObj(res2)) {
6620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6621 } else {
6622 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6624 }
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632 PyObject *resultobj = 0;
6633 wxSize result;
6634
6635 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6636 {
6637 if (!wxPyCheckForApp()) SWIG_fail;
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = wxGetDisplaySize();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6651 PyObject *resultobj = 0;
6652 int *arg1 = (int *) 0 ;
6653 int *arg2 = (int *) 0 ;
6654 int temp1 ;
6655 int res1 = SWIG_TMPOBJ ;
6656 int temp2 ;
6657 int res2 = SWIG_TMPOBJ ;
6658
6659 arg1 = &temp1;
6660 arg2 = &temp2;
6661 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6662 {
6663 if (!wxPyCheckForApp()) SWIG_fail;
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 wxDisplaySizeMM(arg1,arg2);
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 resultobj = SWIG_Py_Void();
6670 if (SWIG_IsTmpObj(res1)) {
6671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6672 } else {
6673 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6675 }
6676 if (SWIG_IsTmpObj(res2)) {
6677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6678 } else {
6679 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6681 }
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6689 PyObject *resultobj = 0;
6690 wxSize result;
6691
6692 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6693 {
6694 if (!wxPyCheckForApp()) SWIG_fail;
6695 PyThreadState* __tstate = wxPyBeginAllowThreads();
6696 result = wxGetDisplaySizeMM();
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6708 PyObject *resultobj = 0;
6709 int *arg1 = (int *) 0 ;
6710 int *arg2 = (int *) 0 ;
6711 int *arg3 = (int *) 0 ;
6712 int *arg4 = (int *) 0 ;
6713 int temp1 ;
6714 int res1 = SWIG_TMPOBJ ;
6715 int temp2 ;
6716 int res2 = SWIG_TMPOBJ ;
6717 int temp3 ;
6718 int res3 = SWIG_TMPOBJ ;
6719 int temp4 ;
6720 int res4 = SWIG_TMPOBJ ;
6721
6722 arg1 = &temp1;
6723 arg2 = &temp2;
6724 arg3 = &temp3;
6725 arg4 = &temp4;
6726 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6727 {
6728 if (!wxPyCheckForApp()) SWIG_fail;
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 if (SWIG_IsTmpObj(res1)) {
6736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6737 } else {
6738 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6740 }
6741 if (SWIG_IsTmpObj(res2)) {
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6743 } else {
6744 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6746 }
6747 if (SWIG_IsTmpObj(res3)) {
6748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6749 } else {
6750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6752 }
6753 if (SWIG_IsTmpObj(res4)) {
6754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6755 } else {
6756 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6758 }
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6766 PyObject *resultobj = 0;
6767 wxRect result;
6768
6769 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6770 {
6771 if (!wxPyCheckForApp()) SWIG_fail;
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = wxGetClientDisplayRect();
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6785 PyObject *resultobj = 0;
6786 wxCursor *arg1 = 0 ;
6787 void *argp1 = 0 ;
6788 int res1 = 0 ;
6789 PyObject * obj0 = 0 ;
6790 char * kwnames[] = {
6791 (char *) "cursor", NULL
6792 };
6793
6794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6795 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6796 if (!SWIG_IsOK(res1)) {
6797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6798 }
6799 if (!argp1) {
6800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6801 }
6802 arg1 = reinterpret_cast< wxCursor * >(argp1);
6803 {
6804 if (!wxPyCheckForApp()) SWIG_fail;
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 wxSetCursor(*arg1);
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_Py_Void();
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 void *result = 0 ;
6820
6821 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6822 {
6823 if (!wxPyCheckForApp()) SWIG_fail;
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (void *)wxGetXDisplay();
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6837 PyObject *resultobj = 0;
6838 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6839 void *argp1 = 0 ;
6840 int res1 = 0 ;
6841 PyObject * obj0 = 0 ;
6842 char * kwnames[] = {
6843 (char *) "cursor", NULL
6844 };
6845
6846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6847 if (obj0) {
6848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6849 if (!SWIG_IsOK(res1)) {
6850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6851 }
6852 arg1 = reinterpret_cast< wxCursor * >(argp1);
6853 }
6854 {
6855 if (!wxPyCheckForApp()) SWIG_fail;
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 wxBeginBusyCursor(arg1);
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_Py_Void();
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxPoint result;
6871
6872 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6873 {
6874 if (!wxPyCheckForApp()) SWIG_fail;
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = wxGetMousePosition();
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6888 PyObject *resultobj = 0;
6889 wxWindow *result = 0 ;
6890
6891 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6892 {
6893 if (!wxPyCheckForApp()) SWIG_fail;
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (wxWindow *)FindWindowAtPointer();
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 {
6900 resultobj = wxPyMake_wxObject(result, 0);
6901 }
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909 PyObject *resultobj = 0;
6910 wxWindow *result = 0 ;
6911
6912 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6913 {
6914 if (!wxPyCheckForApp()) SWIG_fail;
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (wxWindow *)wxGetActiveWindow();
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 {
6921 resultobj = wxPyMake_wxObject(result, 0);
6922 }
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxPoint *arg1 = 0 ;
6932 wxWindow *result = 0 ;
6933 wxPoint temp1 ;
6934 PyObject * obj0 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "pt", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6940 {
6941 arg1 = &temp1;
6942 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6943 }
6944 {
6945 if (!wxPyCheckForApp()) SWIG_fail;
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 {
6952 resultobj = wxPyMake_wxObject(result, 0);
6953 }
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj = 0;
6962 wxPoint *arg1 = 0 ;
6963 wxWindow *result = 0 ;
6964 wxPoint temp1 ;
6965 PyObject * obj0 = 0 ;
6966 char * kwnames[] = {
6967 (char *) "pt", NULL
6968 };
6969
6970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6971 {
6972 arg1 = &temp1;
6973 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6974 }
6975 {
6976 if (!wxPyCheckForApp()) SWIG_fail;
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 {
6983 resultobj = wxPyMake_wxObject(result, 0);
6984 }
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj = 0;
6993 wxWindow *arg1 = (wxWindow *) 0 ;
6994 wxWindow *result = 0 ;
6995 void *argp1 = 0 ;
6996 int res1 = 0 ;
6997 PyObject * obj0 = 0 ;
6998 char * kwnames[] = {
6999 (char *) "win", NULL
7000 };
7001
7002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7004 if (!SWIG_IsOK(res1)) {
7005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7006 }
7007 arg1 = reinterpret_cast< wxWindow * >(argp1);
7008 {
7009 if (!wxPyCheckForApp()) SWIG_fail;
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 result = (wxWindow *)wxGetTopLevelParent(arg1);
7012 wxPyEndAllowThreads(__tstate);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 {
7016 resultobj = wxPyMake_wxObject(result, 0);
7017 }
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = 0;
7026 wxString *arg1 = 0 ;
7027 bool result;
7028 bool temp1 = false ;
7029 PyObject * obj0 = 0 ;
7030 char * kwnames[] = {
7031 (char *) "url", NULL
7032 };
7033
7034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7035 {
7036 arg1 = wxString_in_helper(obj0);
7037 if (arg1 == NULL) SWIG_fail;
7038 temp1 = true;
7039 }
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 {
7047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7048 }
7049 {
7050 if (temp1)
7051 delete arg1;
7052 }
7053 return resultobj;
7054 fail:
7055 {
7056 if (temp1)
7057 delete arg1;
7058 }
7059 return NULL;
7060 }
7061
7062
7063 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj = 0;
7065 wxKeyCode arg1 ;
7066 bool result;
7067 int val1 ;
7068 int ecode1 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 char * kwnames[] = {
7071 (char *) "key", NULL
7072 };
7073
7074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7075 ecode1 = SWIG_AsVal_int(obj0, &val1);
7076 if (!SWIG_IsOK(ecode1)) {
7077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7078 }
7079 arg1 = static_cast< wxKeyCode >(val1);
7080 {
7081 if (!wxPyCheckForApp()) SWIG_fail;
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (bool)wxGetKeyState(arg1);
7084 wxPyEndAllowThreads(__tstate);
7085 if (PyErr_Occurred()) SWIG_fail;
7086 }
7087 {
7088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7089 }
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7097 PyObject *resultobj = 0;
7098 wxMouseState *result = 0 ;
7099
7100 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (wxMouseState *)new wxMouseState();
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7115 PyObject *resultobj = 0;
7116 wxMouseState *arg1 = (wxMouseState *) 0 ;
7117 void *argp1 = 0 ;
7118 int res1 = 0 ;
7119 PyObject *swig_obj[1] ;
7120
7121 if (!args) SWIG_fail;
7122 swig_obj[0] = args;
7123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7126 }
7127 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 delete arg1;
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 resultobj = SWIG_Py_Void();
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7143 PyObject *resultobj = 0;
7144 wxMouseState *arg1 = (wxMouseState *) 0 ;
7145 int result;
7146 void *argp1 = 0 ;
7147 int res1 = 0 ;
7148 PyObject *swig_obj[1] ;
7149
7150 if (!args) SWIG_fail;
7151 swig_obj[0] = args;
7152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7153 if (!SWIG_IsOK(res1)) {
7154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7155 }
7156 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 result = (int)(arg1)->GetX();
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 resultobj = SWIG_From_int(static_cast< int >(result));
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7171 PyObject *resultobj = 0;
7172 wxMouseState *arg1 = (wxMouseState *) 0 ;
7173 int result;
7174 void *argp1 = 0 ;
7175 int res1 = 0 ;
7176 PyObject *swig_obj[1] ;
7177
7178 if (!args) SWIG_fail;
7179 swig_obj[0] = args;
7180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7181 if (!SWIG_IsOK(res1)) {
7182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7183 }
7184 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 result = (int)(arg1)->GetY();
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 resultobj = SWIG_From_int(static_cast< int >(result));
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7199 PyObject *resultobj = 0;
7200 wxMouseState *arg1 = (wxMouseState *) 0 ;
7201 bool result;
7202 void *argp1 = 0 ;
7203 int res1 = 0 ;
7204 PyObject *swig_obj[1] ;
7205
7206 if (!args) SWIG_fail;
7207 swig_obj[0] = args;
7208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7209 if (!SWIG_IsOK(res1)) {
7210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7211 }
7212 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7213 {
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 result = (bool)(arg1)->LeftDown();
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 {
7220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7229 PyObject *resultobj = 0;
7230 wxMouseState *arg1 = (wxMouseState *) 0 ;
7231 bool result;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 PyObject *swig_obj[1] ;
7235
7236 if (!args) SWIG_fail;
7237 swig_obj[0] = args;
7238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7239 if (!SWIG_IsOK(res1)) {
7240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7241 }
7242 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 result = (bool)(arg1)->MiddleDown();
7246 wxPyEndAllowThreads(__tstate);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 {
7250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7251 }
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7259 PyObject *resultobj = 0;
7260 wxMouseState *arg1 = (wxMouseState *) 0 ;
7261 bool result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 PyObject *swig_obj[1] ;
7265
7266 if (!args) SWIG_fail;
7267 swig_obj[0] = args;
7268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7269 if (!SWIG_IsOK(res1)) {
7270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7271 }
7272 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 result = (bool)(arg1)->RightDown();
7276 wxPyEndAllowThreads(__tstate);
7277 if (PyErr_Occurred()) SWIG_fail;
7278 }
7279 {
7280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7281 }
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7289 PyObject *resultobj = 0;
7290 wxMouseState *arg1 = (wxMouseState *) 0 ;
7291 bool result;
7292 void *argp1 = 0 ;
7293 int res1 = 0 ;
7294 PyObject *swig_obj[1] ;
7295
7296 if (!args) SWIG_fail;
7297 swig_obj[0] = args;
7298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7299 if (!SWIG_IsOK(res1)) {
7300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7301 }
7302 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = (bool)(arg1)->ControlDown();
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 {
7310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7311 }
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7319 PyObject *resultobj = 0;
7320 wxMouseState *arg1 = (wxMouseState *) 0 ;
7321 bool result;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 PyObject *swig_obj[1] ;
7325
7326 if (!args) SWIG_fail;
7327 swig_obj[0] = args;
7328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7331 }
7332 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (bool)(arg1)->ShiftDown();
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 {
7340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7341 }
7342 return resultobj;
7343 fail:
7344 return NULL;
7345 }
7346
7347
7348 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7349 PyObject *resultobj = 0;
7350 wxMouseState *arg1 = (wxMouseState *) 0 ;
7351 bool result;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 PyObject *swig_obj[1] ;
7355
7356 if (!args) SWIG_fail;
7357 swig_obj[0] = args;
7358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7359 if (!SWIG_IsOK(res1)) {
7360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7361 }
7362 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7363 {
7364 PyThreadState* __tstate = wxPyBeginAllowThreads();
7365 result = (bool)(arg1)->AltDown();
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7371 }
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxMouseState *arg1 = (wxMouseState *) 0 ;
7381 bool result;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 PyObject *swig_obj[1] ;
7385
7386 if (!args) SWIG_fail;
7387 swig_obj[0] = args;
7388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7391 }
7392 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (bool)(arg1)->MetaDown();
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 {
7400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7401 }
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7409 PyObject *resultobj = 0;
7410 wxMouseState *arg1 = (wxMouseState *) 0 ;
7411 bool result;
7412 void *argp1 = 0 ;
7413 int res1 = 0 ;
7414 PyObject *swig_obj[1] ;
7415
7416 if (!args) SWIG_fail;
7417 swig_obj[0] = args;
7418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7419 if (!SWIG_IsOK(res1)) {
7420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7421 }
7422 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 result = (bool)(arg1)->CmdDown();
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 {
7430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7431 }
7432 return resultobj;
7433 fail:
7434 return NULL;
7435 }
7436
7437
7438 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7439 PyObject *resultobj = 0;
7440 wxMouseState *arg1 = (wxMouseState *) 0 ;
7441 int arg2 ;
7442 void *argp1 = 0 ;
7443 int res1 = 0 ;
7444 int val2 ;
7445 int ecode2 = 0 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 char * kwnames[] = {
7449 (char *) "self",(char *) "x", NULL
7450 };
7451
7452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7454 if (!SWIG_IsOK(res1)) {
7455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7456 }
7457 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7458 ecode2 = SWIG_AsVal_int(obj1, &val2);
7459 if (!SWIG_IsOK(ecode2)) {
7460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7461 }
7462 arg2 = static_cast< int >(val2);
7463 {
7464 PyThreadState* __tstate = wxPyBeginAllowThreads();
7465 (arg1)->SetX(arg2);
7466 wxPyEndAllowThreads(__tstate);
7467 if (PyErr_Occurred()) SWIG_fail;
7468 }
7469 resultobj = SWIG_Py_Void();
7470 return resultobj;
7471 fail:
7472 return NULL;
7473 }
7474
7475
7476 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7477 PyObject *resultobj = 0;
7478 wxMouseState *arg1 = (wxMouseState *) 0 ;
7479 int arg2 ;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 int val2 ;
7483 int ecode2 = 0 ;
7484 PyObject * obj0 = 0 ;
7485 PyObject * obj1 = 0 ;
7486 char * kwnames[] = {
7487 (char *) "self",(char *) "y", NULL
7488 };
7489
7490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7492 if (!SWIG_IsOK(res1)) {
7493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7494 }
7495 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7496 ecode2 = SWIG_AsVal_int(obj1, &val2);
7497 if (!SWIG_IsOK(ecode2)) {
7498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7499 }
7500 arg2 = static_cast< int >(val2);
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 (arg1)->SetY(arg2);
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 resultobj = SWIG_Py_Void();
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7515 PyObject *resultobj = 0;
7516 wxMouseState *arg1 = (wxMouseState *) 0 ;
7517 bool arg2 ;
7518 void *argp1 = 0 ;
7519 int res1 = 0 ;
7520 bool val2 ;
7521 int ecode2 = 0 ;
7522 PyObject * obj0 = 0 ;
7523 PyObject * obj1 = 0 ;
7524 char * kwnames[] = {
7525 (char *) "self",(char *) "down", NULL
7526 };
7527
7528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7530 if (!SWIG_IsOK(res1)) {
7531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7532 }
7533 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7535 if (!SWIG_IsOK(ecode2)) {
7536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7537 }
7538 arg2 = static_cast< bool >(val2);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 (arg1)->SetLeftDown(arg2);
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 resultobj = SWIG_Py_Void();
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj = 0;
7554 wxMouseState *arg1 = (wxMouseState *) 0 ;
7555 bool arg2 ;
7556 void *argp1 = 0 ;
7557 int res1 = 0 ;
7558 bool val2 ;
7559 int ecode2 = 0 ;
7560 PyObject * obj0 = 0 ;
7561 PyObject * obj1 = 0 ;
7562 char * kwnames[] = {
7563 (char *) "self",(char *) "down", NULL
7564 };
7565
7566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7568 if (!SWIG_IsOK(res1)) {
7569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7570 }
7571 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7572 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7573 if (!SWIG_IsOK(ecode2)) {
7574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7575 }
7576 arg2 = static_cast< bool >(val2);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 (arg1)->SetMiddleDown(arg2);
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 resultobj = SWIG_Py_Void();
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj = 0;
7592 wxMouseState *arg1 = (wxMouseState *) 0 ;
7593 bool arg2 ;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 bool val2 ;
7597 int ecode2 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "down", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7608 }
7609 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7610 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7611 if (!SWIG_IsOK(ecode2)) {
7612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7613 }
7614 arg2 = static_cast< bool >(val2);
7615 {
7616 PyThreadState* __tstate = wxPyBeginAllowThreads();
7617 (arg1)->SetRightDown(arg2);
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 resultobj = SWIG_Py_Void();
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7629 PyObject *resultobj = 0;
7630 wxMouseState *arg1 = (wxMouseState *) 0 ;
7631 bool arg2 ;
7632 void *argp1 = 0 ;
7633 int res1 = 0 ;
7634 bool val2 ;
7635 int ecode2 = 0 ;
7636 PyObject * obj0 = 0 ;
7637 PyObject * obj1 = 0 ;
7638 char * kwnames[] = {
7639 (char *) "self",(char *) "down", NULL
7640 };
7641
7642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7644 if (!SWIG_IsOK(res1)) {
7645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7646 }
7647 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7649 if (!SWIG_IsOK(ecode2)) {
7650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7651 }
7652 arg2 = static_cast< bool >(val2);
7653 {
7654 PyThreadState* __tstate = wxPyBeginAllowThreads();
7655 (arg1)->SetControlDown(arg2);
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 resultobj = SWIG_Py_Void();
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj = 0;
7668 wxMouseState *arg1 = (wxMouseState *) 0 ;
7669 bool arg2 ;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 bool val2 ;
7673 int ecode2 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "down", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7684 }
7685 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7686 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7689 }
7690 arg2 = static_cast< bool >(val2);
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 (arg1)->SetShiftDown(arg2);
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_Py_Void();
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = 0;
7706 wxMouseState *arg1 = (wxMouseState *) 0 ;
7707 bool arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 bool val2 ;
7711 int ecode2 = 0 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 char * kwnames[] = {
7715 (char *) "self",(char *) "down", NULL
7716 };
7717
7718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7722 }
7723 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7727 }
7728 arg2 = static_cast< bool >(val2);
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 (arg1)->SetAltDown(arg2);
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxMouseState *arg1 = (wxMouseState *) 0 ;
7745 bool arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 bool val2 ;
7749 int ecode2 = 0 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "down", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7760 }
7761 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7765 }
7766 arg2 = static_cast< bool >(val2);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 (arg1)->SetMetaDown(arg2);
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7781 PyObject *obj;
7782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7783 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7784 return SWIG_Py_Void();
7785 }
7786
7787 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788 return SWIG_Python_InitShadowInstance(args);
7789 }
7790
7791 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxMouseState result;
7794
7795 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = wxGetMouseState();
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *resultobj = 0;
7811
7812 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7813 {
7814 if (!wxPyCheckForApp()) SWIG_fail;
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 wxWakeUpMainThread();
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 resultobj = SWIG_Py_Void();
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7828 PyObject *resultobj = 0;
7829
7830 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7831 {
7832 if (!wxPyCheckForApp()) SWIG_fail;
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 wxMutexGuiEnter();
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847
7848 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7849 {
7850 if (!wxPyCheckForApp()) SWIG_fail;
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 wxMutexGuiLeave();
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_Py_Void();
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7864 PyObject *resultobj = 0;
7865 wxMutexGuiLocker *result = 0 ;
7866
7867 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7868 {
7869 if (!wxPyCheckForApp()) SWIG_fail;
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7885 void *argp1 = 0 ;
7886 int res1 = 0 ;
7887 PyObject *swig_obj[1] ;
7888
7889 if (!args) SWIG_fail;
7890 swig_obj[0] = args;
7891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7892 if (!SWIG_IsOK(res1)) {
7893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7894 }
7895 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7896 {
7897 PyThreadState* __tstate = wxPyBeginAllowThreads();
7898 delete arg1;
7899
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_Py_Void();
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7911 PyObject *obj;
7912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7913 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7914 return SWIG_Py_Void();
7915 }
7916
7917 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7918 return SWIG_Python_InitShadowInstance(args);
7919 }
7920
7921 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7922 PyObject *resultobj = 0;
7923 bool result;
7924
7925 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7926 {
7927 PyThreadState* __tstate = wxPyBeginAllowThreads();
7928 result = (bool)wxThread_IsMain();
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 {
7933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7934 }
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 wxString *arg1 = 0 ;
7944 wxToolTip *result = 0 ;
7945 bool temp1 = false ;
7946 PyObject * obj0 = 0 ;
7947 char * kwnames[] = {
7948 (char *) "tip", NULL
7949 };
7950
7951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7952 {
7953 arg1 = wxString_in_helper(obj0);
7954 if (arg1 == NULL) SWIG_fail;
7955 temp1 = true;
7956 }
7957 {
7958 if (!wxPyCheckForApp()) SWIG_fail;
7959 PyThreadState* __tstate = wxPyBeginAllowThreads();
7960 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7961 wxPyEndAllowThreads(__tstate);
7962 if (PyErr_Occurred()) SWIG_fail;
7963 }
7964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7965 {
7966 if (temp1)
7967 delete arg1;
7968 }
7969 return resultobj;
7970 fail:
7971 {
7972 if (temp1)
7973 delete arg1;
7974 }
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxToolTip *arg1 = (wxToolTip *) 0 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 PyObject *swig_obj[1] ;
7985
7986 if (!args) SWIG_fail;
7987 swig_obj[0] = args;
7988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7989 if (!SWIG_IsOK(res1)) {
7990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7991 }
7992 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 delete arg1;
7996
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 resultobj = SWIG_Py_Void();
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8008 PyObject *resultobj = 0;
8009 wxToolTip *arg1 = (wxToolTip *) 0 ;
8010 wxString *arg2 = 0 ;
8011 void *argp1 = 0 ;
8012 int res1 = 0 ;
8013 bool temp2 = false ;
8014 PyObject * obj0 = 0 ;
8015 PyObject * obj1 = 0 ;
8016 char * kwnames[] = {
8017 (char *) "self",(char *) "tip", NULL
8018 };
8019
8020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8022 if (!SWIG_IsOK(res1)) {
8023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8024 }
8025 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8026 {
8027 arg2 = wxString_in_helper(obj1);
8028 if (arg2 == NULL) SWIG_fail;
8029 temp2 = true;
8030 }
8031 {
8032 PyThreadState* __tstate = wxPyBeginAllowThreads();
8033 (arg1)->SetTip((wxString const &)*arg2);
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 resultobj = SWIG_Py_Void();
8038 {
8039 if (temp2)
8040 delete arg2;
8041 }
8042 return resultobj;
8043 fail:
8044 {
8045 if (temp2)
8046 delete arg2;
8047 }
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxToolTip *arg1 = (wxToolTip *) 0 ;
8055 wxString result;
8056 void *argp1 = 0 ;
8057 int res1 = 0 ;
8058 PyObject *swig_obj[1] ;
8059
8060 if (!args) SWIG_fail;
8061 swig_obj[0] = args;
8062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8063 if (!SWIG_IsOK(res1)) {
8064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8065 }
8066 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8067 {
8068 PyThreadState* __tstate = wxPyBeginAllowThreads();
8069 result = (arg1)->GetTip();
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 {
8074 #if wxUSE_UNICODE
8075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8076 #else
8077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8078 #endif
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8087 PyObject *resultobj = 0;
8088 wxToolTip *arg1 = (wxToolTip *) 0 ;
8089 wxWindow *result = 0 ;
8090 void *argp1 = 0 ;
8091 int res1 = 0 ;
8092 PyObject *swig_obj[1] ;
8093
8094 if (!args) SWIG_fail;
8095 swig_obj[0] = args;
8096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8097 if (!SWIG_IsOK(res1)) {
8098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8099 }
8100 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxWindow *)(arg1)->GetWindow();
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 resultobj = wxPyMake_wxObject(result, 0);
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 bool arg1 ;
8119 bool val1 ;
8120 int ecode1 = 0 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "flag", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8127 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8128 if (!SWIG_IsOK(ecode1)) {
8129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8130 }
8131 arg1 = static_cast< bool >(val1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 wxToolTip::Enable(arg1);
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_Py_Void();
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 long arg1 ;
8148 long val1 ;
8149 int ecode1 = 0 ;
8150 PyObject * obj0 = 0 ;
8151 char * kwnames[] = {
8152 (char *) "milliseconds", NULL
8153 };
8154
8155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8156 ecode1 = SWIG_AsVal_long(obj0, &val1);
8157 if (!SWIG_IsOK(ecode1)) {
8158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8159 }
8160 arg1 = static_cast< long >(val1);
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 wxToolTip::SetDelay(arg1);
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 resultobj = SWIG_Py_Void();
8168 return resultobj;
8169 fail:
8170 return NULL;
8171 }
8172
8173
8174 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8175 PyObject *obj;
8176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8177 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8178 return SWIG_Py_Void();
8179 }
8180
8181 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8182 return SWIG_Python_InitShadowInstance(args);
8183 }
8184
8185 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxWindow *arg1 = (wxWindow *) 0 ;
8188 wxSize *arg2 = 0 ;
8189 wxCaret *result = 0 ;
8190 void *argp1 = 0 ;
8191 int res1 = 0 ;
8192 wxSize temp2 ;
8193 PyObject * obj0 = 0 ;
8194 PyObject * obj1 = 0 ;
8195 char * kwnames[] = {
8196 (char *) "window",(char *) "size", NULL
8197 };
8198
8199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8201 if (!SWIG_IsOK(res1)) {
8202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8203 }
8204 arg1 = reinterpret_cast< wxWindow * >(argp1);
8205 {
8206 arg2 = &temp2;
8207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8208 }
8209 {
8210 if (!wxPyCheckForApp()) SWIG_fail;
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224 PyObject *resultobj = 0;
8225 wxCaret *arg1 = (wxCaret *) 0 ;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 PyObject *swig_obj[1] ;
8229
8230 if (!args) SWIG_fail;
8231 swig_obj[0] = args;
8232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8233 if (!SWIG_IsOK(res1)) {
8234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8235 }
8236 arg1 = reinterpret_cast< wxCaret * >(argp1);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 delete arg1;
8240
8241 wxPyEndAllowThreads(__tstate);
8242 if (PyErr_Occurred()) SWIG_fail;
8243 }
8244 resultobj = SWIG_Py_Void();
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252 PyObject *resultobj = 0;
8253 wxCaret *arg1 = (wxCaret *) 0 ;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 PyObject *swig_obj[1] ;
8257
8258 if (!args) SWIG_fail;
8259 swig_obj[0] = args;
8260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8261 if (!SWIG_IsOK(res1)) {
8262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8263 }
8264 arg1 = reinterpret_cast< wxCaret * >(argp1);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 wxCaret_Destroy(arg1);
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_Py_Void();
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8279 PyObject *resultobj = 0;
8280 wxCaret *arg1 = (wxCaret *) 0 ;
8281 bool result;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 PyObject *swig_obj[1] ;
8285
8286 if (!args) SWIG_fail;
8287 swig_obj[0] = args;
8288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8289 if (!SWIG_IsOK(res1)) {
8290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8291 }
8292 arg1 = reinterpret_cast< wxCaret * >(argp1);
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (bool)(arg1)->IsOk();
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 {
8300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8301 }
8302 return resultobj;
8303 fail:
8304 return NULL;
8305 }
8306
8307
8308 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8309 PyObject *resultobj = 0;
8310 wxCaret *arg1 = (wxCaret *) 0 ;
8311 bool result;
8312 void *argp1 = 0 ;
8313 int res1 = 0 ;
8314 PyObject *swig_obj[1] ;
8315
8316 if (!args) SWIG_fail;
8317 swig_obj[0] = args;
8318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8319 if (!SWIG_IsOK(res1)) {
8320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8321 }
8322 arg1 = reinterpret_cast< wxCaret * >(argp1);
8323 {
8324 PyThreadState* __tstate = wxPyBeginAllowThreads();
8325 result = (bool)(arg1)->IsVisible();
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 {
8330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8331 }
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8339 PyObject *resultobj = 0;
8340 wxCaret *arg1 = (wxCaret *) 0 ;
8341 wxPoint result;
8342 void *argp1 = 0 ;
8343 int res1 = 0 ;
8344 PyObject *swig_obj[1] ;
8345
8346 if (!args) SWIG_fail;
8347 swig_obj[0] = args;
8348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8349 if (!SWIG_IsOK(res1)) {
8350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8351 }
8352 arg1 = reinterpret_cast< wxCaret * >(argp1);
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (arg1)->GetPosition();
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8360 return resultobj;
8361 fail:
8362 return NULL;
8363 }
8364
8365
8366 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8367 PyObject *resultobj = 0;
8368 wxCaret *arg1 = (wxCaret *) 0 ;
8369 int *arg2 = (int *) 0 ;
8370 int *arg3 = (int *) 0 ;
8371 void *argp1 = 0 ;
8372 int res1 = 0 ;
8373 int temp2 ;
8374 int res2 = SWIG_TMPOBJ ;
8375 int temp3 ;
8376 int res3 = SWIG_TMPOBJ ;
8377 PyObject *swig_obj[1] ;
8378
8379 arg2 = &temp2;
8380 arg3 = &temp3;
8381 if (!args) SWIG_fail;
8382 swig_obj[0] = args;
8383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8384 if (!SWIG_IsOK(res1)) {
8385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8386 }
8387 arg1 = reinterpret_cast< wxCaret * >(argp1);
8388 {
8389 PyThreadState* __tstate = wxPyBeginAllowThreads();
8390 (arg1)->GetPosition(arg2,arg3);
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_Py_Void();
8395 if (SWIG_IsTmpObj(res2)) {
8396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8397 } else {
8398 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8400 }
8401 if (SWIG_IsTmpObj(res3)) {
8402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8403 } else {
8404 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8406 }
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 PyObject *resultobj = 0;
8415 wxCaret *arg1 = (wxCaret *) 0 ;
8416 wxSize result;
8417 void *argp1 = 0 ;
8418 int res1 = 0 ;
8419 PyObject *swig_obj[1] ;
8420
8421 if (!args) SWIG_fail;
8422 swig_obj[0] = args;
8423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8424 if (!SWIG_IsOK(res1)) {
8425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8426 }
8427 arg1 = reinterpret_cast< wxCaret * >(argp1);
8428 {
8429 PyThreadState* __tstate = wxPyBeginAllowThreads();
8430 result = (arg1)->GetSize();
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8442 PyObject *resultobj = 0;
8443 wxCaret *arg1 = (wxCaret *) 0 ;
8444 int *arg2 = (int *) 0 ;
8445 int *arg3 = (int *) 0 ;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 int temp2 ;
8449 int res2 = SWIG_TMPOBJ ;
8450 int temp3 ;
8451 int res3 = SWIG_TMPOBJ ;
8452 PyObject *swig_obj[1] ;
8453
8454 arg2 = &temp2;
8455 arg3 = &temp3;
8456 if (!args) SWIG_fail;
8457 swig_obj[0] = args;
8458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8459 if (!SWIG_IsOK(res1)) {
8460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8461 }
8462 arg1 = reinterpret_cast< wxCaret * >(argp1);
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 (arg1)->GetSize(arg2,arg3);
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 resultobj = SWIG_Py_Void();
8470 if (SWIG_IsTmpObj(res2)) {
8471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8472 } else {
8473 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8475 }
8476 if (SWIG_IsTmpObj(res3)) {
8477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8478 } else {
8479 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8481 }
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxCaret *arg1 = (wxCaret *) 0 ;
8491 wxWindow *result = 0 ;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 PyObject *swig_obj[1] ;
8495
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8501 }
8502 arg1 = reinterpret_cast< wxCaret * >(argp1);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 result = (wxWindow *)(arg1)->GetWindow();
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 resultobj = wxPyMake_wxObject(result, 0);
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8519 PyObject *resultobj = 0;
8520 wxCaret *arg1 = (wxCaret *) 0 ;
8521 int arg2 ;
8522 int arg3 ;
8523 void *argp1 = 0 ;
8524 int res1 = 0 ;
8525 int val2 ;
8526 int ecode2 = 0 ;
8527 int val3 ;
8528 int ecode3 = 0 ;
8529 PyObject * obj0 = 0 ;
8530 PyObject * obj1 = 0 ;
8531 PyObject * obj2 = 0 ;
8532 char * kwnames[] = {
8533 (char *) "self",(char *) "x",(char *) "y", NULL
8534 };
8535
8536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8538 if (!SWIG_IsOK(res1)) {
8539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8540 }
8541 arg1 = reinterpret_cast< wxCaret * >(argp1);
8542 ecode2 = SWIG_AsVal_int(obj1, &val2);
8543 if (!SWIG_IsOK(ecode2)) {
8544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8545 }
8546 arg2 = static_cast< int >(val2);
8547 ecode3 = SWIG_AsVal_int(obj2, &val3);
8548 if (!SWIG_IsOK(ecode3)) {
8549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8550 }
8551 arg3 = static_cast< int >(val3);
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 (arg1)->Move(arg2,arg3);
8555 wxPyEndAllowThreads(__tstate);
8556 if (PyErr_Occurred()) SWIG_fail;
8557 }
8558 resultobj = SWIG_Py_Void();
8559 return resultobj;
8560 fail:
8561 return NULL;
8562 }
8563
8564
8565 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8566 PyObject *resultobj = 0;
8567 wxCaret *arg1 = (wxCaret *) 0 ;
8568 wxPoint *arg2 = 0 ;
8569 void *argp1 = 0 ;
8570 int res1 = 0 ;
8571 wxPoint temp2 ;
8572 PyObject * obj0 = 0 ;
8573 PyObject * obj1 = 0 ;
8574 char * kwnames[] = {
8575 (char *) "self",(char *) "pt", NULL
8576 };
8577
8578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8580 if (!SWIG_IsOK(res1)) {
8581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8582 }
8583 arg1 = reinterpret_cast< wxCaret * >(argp1);
8584 {
8585 arg2 = &temp2;
8586 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8587 }
8588 {
8589 PyThreadState* __tstate = wxPyBeginAllowThreads();
8590 (arg1)->Move((wxPoint const &)*arg2);
8591 wxPyEndAllowThreads(__tstate);
8592 if (PyErr_Occurred()) SWIG_fail;
8593 }
8594 resultobj = SWIG_Py_Void();
8595 return resultobj;
8596 fail:
8597 return NULL;
8598 }
8599
8600
8601 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8602 PyObject *resultobj = 0;
8603 wxCaret *arg1 = (wxCaret *) 0 ;
8604 int arg2 ;
8605 int arg3 ;
8606 void *argp1 = 0 ;
8607 int res1 = 0 ;
8608 int val2 ;
8609 int ecode2 = 0 ;
8610 int val3 ;
8611 int ecode3 = 0 ;
8612 PyObject * obj0 = 0 ;
8613 PyObject * obj1 = 0 ;
8614 PyObject * obj2 = 0 ;
8615 char * kwnames[] = {
8616 (char *) "self",(char *) "width",(char *) "height", NULL
8617 };
8618
8619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8621 if (!SWIG_IsOK(res1)) {
8622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8623 }
8624 arg1 = reinterpret_cast< wxCaret * >(argp1);
8625 ecode2 = SWIG_AsVal_int(obj1, &val2);
8626 if (!SWIG_IsOK(ecode2)) {
8627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8628 }
8629 arg2 = static_cast< int >(val2);
8630 ecode3 = SWIG_AsVal_int(obj2, &val3);
8631 if (!SWIG_IsOK(ecode3)) {
8632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8633 }
8634 arg3 = static_cast< int >(val3);
8635 {
8636 PyThreadState* __tstate = wxPyBeginAllowThreads();
8637 (arg1)->SetSize(arg2,arg3);
8638 wxPyEndAllowThreads(__tstate);
8639 if (PyErr_Occurred()) SWIG_fail;
8640 }
8641 resultobj = SWIG_Py_Void();
8642 return resultobj;
8643 fail:
8644 return NULL;
8645 }
8646
8647
8648 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8649 PyObject *resultobj = 0;
8650 wxCaret *arg1 = (wxCaret *) 0 ;
8651 wxSize *arg2 = 0 ;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 wxSize temp2 ;
8655 PyObject * obj0 = 0 ;
8656 PyObject * obj1 = 0 ;
8657 char * kwnames[] = {
8658 (char *) "self",(char *) "size", NULL
8659 };
8660
8661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8663 if (!SWIG_IsOK(res1)) {
8664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8665 }
8666 arg1 = reinterpret_cast< wxCaret * >(argp1);
8667 {
8668 arg2 = &temp2;
8669 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8670 }
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 (arg1)->SetSize((wxSize const &)*arg2);
8674 wxPyEndAllowThreads(__tstate);
8675 if (PyErr_Occurred()) SWIG_fail;
8676 }
8677 resultobj = SWIG_Py_Void();
8678 return resultobj;
8679 fail:
8680 return NULL;
8681 }
8682
8683
8684 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8685 PyObject *resultobj = 0;
8686 wxCaret *arg1 = (wxCaret *) 0 ;
8687 int arg2 = (int) true ;
8688 void *argp1 = 0 ;
8689 int res1 = 0 ;
8690 int val2 ;
8691 int ecode2 = 0 ;
8692 PyObject * obj0 = 0 ;
8693 PyObject * obj1 = 0 ;
8694 char * kwnames[] = {
8695 (char *) "self",(char *) "show", NULL
8696 };
8697
8698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8700 if (!SWIG_IsOK(res1)) {
8701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8702 }
8703 arg1 = reinterpret_cast< wxCaret * >(argp1);
8704 if (obj1) {
8705 ecode2 = SWIG_AsVal_int(obj1, &val2);
8706 if (!SWIG_IsOK(ecode2)) {
8707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8708 }
8709 arg2 = static_cast< int >(val2);
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 (arg1)->Show(arg2);
8714 wxPyEndAllowThreads(__tstate);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 resultobj = SWIG_Py_Void();
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxCaret *arg1 = (wxCaret *) 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 PyObject *swig_obj[1] ;
8730
8731 if (!args) SWIG_fail;
8732 swig_obj[0] = args;
8733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8736 }
8737 arg1 = reinterpret_cast< wxCaret * >(argp1);
8738 {
8739 PyThreadState* __tstate = wxPyBeginAllowThreads();
8740 (arg1)->Hide();
8741 wxPyEndAllowThreads(__tstate);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 resultobj = SWIG_Py_Void();
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752 PyObject *resultobj = 0;
8753 int result;
8754
8755 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (int)wxCaret::GetBlinkTime();
8759 wxPyEndAllowThreads(__tstate);
8760 if (PyErr_Occurred()) SWIG_fail;
8761 }
8762 resultobj = SWIG_From_int(static_cast< int >(result));
8763 return resultobj;
8764 fail:
8765 return NULL;
8766 }
8767
8768
8769 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8770 PyObject *resultobj = 0;
8771 int arg1 ;
8772 int val1 ;
8773 int ecode1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 char * kwnames[] = {
8776 (char *) "milliseconds", NULL
8777 };
8778
8779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8780 ecode1 = SWIG_AsVal_int(obj0, &val1);
8781 if (!SWIG_IsOK(ecode1)) {
8782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8783 }
8784 arg1 = static_cast< int >(val1);
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 wxCaret::SetBlinkTime(arg1);
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_Py_Void();
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799 PyObject *obj;
8800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8801 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8802 return SWIG_Py_Void();
8803 }
8804
8805 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8806 return SWIG_Python_InitShadowInstance(args);
8807 }
8808
8809 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj = 0;
8811 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8812 wxBusyCursor *result = 0 ;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 PyObject * obj0 = 0 ;
8816 char * kwnames[] = {
8817 (char *) "cursor", NULL
8818 };
8819
8820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8821 if (obj0) {
8822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8823 if (!SWIG_IsOK(res1)) {
8824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8825 }
8826 arg1 = reinterpret_cast< wxCursor * >(argp1);
8827 }
8828 {
8829 if (!wxPyCheckForApp()) SWIG_fail;
8830 PyThreadState* __tstate = wxPyBeginAllowThreads();
8831 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8843 PyObject *resultobj = 0;
8844 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8845 void *argp1 = 0 ;
8846 int res1 = 0 ;
8847 PyObject *swig_obj[1] ;
8848
8849 if (!args) SWIG_fail;
8850 swig_obj[0] = args;
8851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8854 }
8855 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 delete arg1;
8859
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 resultobj = SWIG_Py_Void();
8864 return resultobj;
8865 fail:
8866 return NULL;
8867 }
8868
8869
8870 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8871 PyObject *obj;
8872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8873 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8874 return SWIG_Py_Void();
8875 }
8876
8877 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8878 return SWIG_Python_InitShadowInstance(args);
8879 }
8880
8881 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8882 PyObject *resultobj = 0;
8883 wxWindow *arg1 = (wxWindow *) NULL ;
8884 wxWindowDisabler *result = 0 ;
8885 void *argp1 = 0 ;
8886 int res1 = 0 ;
8887 PyObject * obj0 = 0 ;
8888 char * kwnames[] = {
8889 (char *) "winToSkip", NULL
8890 };
8891
8892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8893 if (obj0) {
8894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8897 }
8898 arg1 = reinterpret_cast< wxWindow * >(argp1);
8899 }
8900 {
8901 if (!wxPyCheckForApp()) SWIG_fail;
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8915 PyObject *resultobj = 0;
8916 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8917 void *argp1 = 0 ;
8918 int res1 = 0 ;
8919 PyObject *swig_obj[1] ;
8920
8921 if (!args) SWIG_fail;
8922 swig_obj[0] = args;
8923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8926 }
8927 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 delete arg1;
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 resultobj = SWIG_Py_Void();
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *obj;
8944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8945 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8946 return SWIG_Py_Void();
8947 }
8948
8949 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8950 return SWIG_Python_InitShadowInstance(args);
8951 }
8952
8953 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8954 PyObject *resultobj = 0;
8955 wxString *arg1 = 0 ;
8956 wxBusyInfo *result = 0 ;
8957 bool temp1 = false ;
8958 PyObject * obj0 = 0 ;
8959 char * kwnames[] = {
8960 (char *) "message", NULL
8961 };
8962
8963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8964 {
8965 arg1 = wxString_in_helper(obj0);
8966 if (arg1 == NULL) SWIG_fail;
8967 temp1 = true;
8968 }
8969 {
8970 if (!wxPyCheckForApp()) SWIG_fail;
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8977 {
8978 if (temp1)
8979 delete arg1;
8980 }
8981 return resultobj;
8982 fail:
8983 {
8984 if (temp1)
8985 delete arg1;
8986 }
8987 return NULL;
8988 }
8989
8990
8991 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 PyObject *resultobj = 0;
8993 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8994 void *argp1 = 0 ;
8995 int res1 = 0 ;
8996 PyObject *swig_obj[1] ;
8997
8998 if (!args) SWIG_fail;
8999 swig_obj[0] = args;
9000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9001 if (!SWIG_IsOK(res1)) {
9002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9003 }
9004 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 delete arg1;
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 resultobj = SWIG_Py_Void();
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9020 PyObject *obj;
9021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9022 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9023 return SWIG_Py_Void();
9024 }
9025
9026 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9027 return SWIG_Python_InitShadowInstance(args);
9028 }
9029
9030 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *resultobj = 0;
9032 wxStopWatch *result = 0 ;
9033
9034 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxStopWatch *)new wxStopWatch();
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9049 PyObject *resultobj = 0;
9050 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9051 long arg2 = (long) 0 ;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 long val2 ;
9055 int ecode2 = 0 ;
9056 PyObject * obj0 = 0 ;
9057 PyObject * obj1 = 0 ;
9058 char * kwnames[] = {
9059 (char *) "self",(char *) "t0", NULL
9060 };
9061
9062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9066 }
9067 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9068 if (obj1) {
9069 ecode2 = SWIG_AsVal_long(obj1, &val2);
9070 if (!SWIG_IsOK(ecode2)) {
9071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9072 }
9073 arg2 = static_cast< long >(val2);
9074 }
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 (arg1)->Start(arg2);
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_Py_Void();
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9089 PyObject *resultobj = 0;
9090 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 PyObject *swig_obj[1] ;
9094
9095 if (!args) SWIG_fail;
9096 swig_obj[0] = args;
9097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9100 }
9101 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 (arg1)->Pause();
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_Py_Void();
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9116 PyObject *resultobj = 0;
9117 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 PyObject *swig_obj[1] ;
9121
9122 if (!args) SWIG_fail;
9123 swig_obj[0] = args;
9124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9127 }
9128 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 (arg1)->Resume();
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = SWIG_Py_Void();
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9145 long result;
9146 void *argp1 = 0 ;
9147 int res1 = 0 ;
9148 PyObject *swig_obj[1] ;
9149
9150 if (!args) SWIG_fail;
9151 swig_obj[0] = args;
9152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9153 if (!SWIG_IsOK(res1)) {
9154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9155 }
9156 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (long)((wxStopWatch const *)arg1)->Time();
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_From_long(static_cast< long >(result));
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *obj;
9172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9173 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9174 return SWIG_Py_Void();
9175 }
9176
9177 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178 return SWIG_Python_InitShadowInstance(args);
9179 }
9180
9181 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = 0;
9183 int arg1 = (int) 9 ;
9184 int arg2 = (int) wxID_FILE1 ;
9185 wxFileHistory *result = 0 ;
9186 int val1 ;
9187 int ecode1 = 0 ;
9188 int val2 ;
9189 int ecode2 = 0 ;
9190 PyObject * obj0 = 0 ;
9191 PyObject * obj1 = 0 ;
9192 char * kwnames[] = {
9193 (char *) "maxFiles",(char *) "idBase", NULL
9194 };
9195
9196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9197 if (obj0) {
9198 ecode1 = SWIG_AsVal_int(obj0, &val1);
9199 if (!SWIG_IsOK(ecode1)) {
9200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9201 }
9202 arg1 = static_cast< int >(val1);
9203 }
9204 if (obj1) {
9205 ecode2 = SWIG_AsVal_int(obj1, &val2);
9206 if (!SWIG_IsOK(ecode2)) {
9207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9208 }
9209 arg2 = static_cast< int >(val2);
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9225 PyObject *resultobj = 0;
9226 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9227 void *argp1 = 0 ;
9228 int res1 = 0 ;
9229 PyObject *swig_obj[1] ;
9230
9231 if (!args) SWIG_fail;
9232 swig_obj[0] = args;
9233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9234 if (!SWIG_IsOK(res1)) {
9235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9236 }
9237 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9238 {
9239 PyThreadState* __tstate = wxPyBeginAllowThreads();
9240 delete arg1;
9241
9242 wxPyEndAllowThreads(__tstate);
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 resultobj = SWIG_Py_Void();
9246 return resultobj;
9247 fail:
9248 return NULL;
9249 }
9250
9251
9252 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9253 PyObject *resultobj = 0;
9254 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9255 wxString *arg2 = 0 ;
9256 void *argp1 = 0 ;
9257 int res1 = 0 ;
9258 bool temp2 = false ;
9259 PyObject * obj0 = 0 ;
9260 PyObject * obj1 = 0 ;
9261 char * kwnames[] = {
9262 (char *) "self",(char *) "file", NULL
9263 };
9264
9265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9267 if (!SWIG_IsOK(res1)) {
9268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9269 }
9270 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9271 {
9272 arg2 = wxString_in_helper(obj1);
9273 if (arg2 == NULL) SWIG_fail;
9274 temp2 = true;
9275 }
9276 {
9277 PyThreadState* __tstate = wxPyBeginAllowThreads();
9278 (arg1)->AddFileToHistory((wxString const &)*arg2);
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_Py_Void();
9283 {
9284 if (temp2)
9285 delete arg2;
9286 }
9287 return resultobj;
9288 fail:
9289 {
9290 if (temp2)
9291 delete arg2;
9292 }
9293 return NULL;
9294 }
9295
9296
9297 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj = 0;
9299 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9300 int arg2 ;
9301 void *argp1 = 0 ;
9302 int res1 = 0 ;
9303 int val2 ;
9304 int ecode2 = 0 ;
9305 PyObject * obj0 = 0 ;
9306 PyObject * obj1 = 0 ;
9307 char * kwnames[] = {
9308 (char *) "self",(char *) "i", NULL
9309 };
9310
9311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9315 }
9316 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9317 ecode2 = SWIG_AsVal_int(obj1, &val2);
9318 if (!SWIG_IsOK(ecode2)) {
9319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9320 }
9321 arg2 = static_cast< int >(val2);
9322 {
9323 PyThreadState* __tstate = wxPyBeginAllowThreads();
9324 (arg1)->RemoveFileFromHistory(arg2);
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 resultobj = SWIG_Py_Void();
9329 return resultobj;
9330 fail:
9331 return NULL;
9332 }
9333
9334
9335 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9336 PyObject *resultobj = 0;
9337 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9338 int result;
9339 void *argp1 = 0 ;
9340 int res1 = 0 ;
9341 PyObject *swig_obj[1] ;
9342
9343 if (!args) SWIG_fail;
9344 swig_obj[0] = args;
9345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9348 }
9349 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_From_int(static_cast< int >(result));
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9364 PyObject *resultobj = 0;
9365 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9366 wxMenu *arg2 = (wxMenu *) 0 ;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 void *argp2 = 0 ;
9370 int res2 = 0 ;
9371 PyObject * obj0 = 0 ;
9372 PyObject * obj1 = 0 ;
9373 char * kwnames[] = {
9374 (char *) "self",(char *) "menu", NULL
9375 };
9376
9377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9381 }
9382 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9384 if (!SWIG_IsOK(res2)) {
9385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9386 }
9387 arg2 = reinterpret_cast< wxMenu * >(argp2);
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 (arg1)->UseMenu(arg2);
9391 wxPyEndAllowThreads(__tstate);
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_Py_Void();
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9402 PyObject *resultobj = 0;
9403 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9404 wxMenu *arg2 = (wxMenu *) 0 ;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 void *argp2 = 0 ;
9408 int res2 = 0 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 char * kwnames[] = {
9412 (char *) "self",(char *) "menu", NULL
9413 };
9414
9415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9417 if (!SWIG_IsOK(res1)) {
9418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9419 }
9420 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9422 if (!SWIG_IsOK(res2)) {
9423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9424 }
9425 arg2 = reinterpret_cast< wxMenu * >(argp2);
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 (arg1)->RemoveMenu(arg2);
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_Py_Void();
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = 0;
9441 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9442 wxConfigBase *arg2 = 0 ;
9443 void *argp1 = 0 ;
9444 int res1 = 0 ;
9445 void *argp2 = 0 ;
9446 int res2 = 0 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 char * kwnames[] = {
9450 (char *) "self",(char *) "config", NULL
9451 };
9452
9453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9457 }
9458 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9459 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9460 if (!SWIG_IsOK(res2)) {
9461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9462 }
9463 if (!argp2) {
9464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9465 }
9466 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 (arg1)->Load(*arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 wxConfigBase *arg2 = 0 ;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 void *argp2 = 0 ;
9487 int res2 = 0 ;
9488 PyObject * obj0 = 0 ;
9489 PyObject * obj1 = 0 ;
9490 char * kwnames[] = {
9491 (char *) "self",(char *) "config", NULL
9492 };
9493
9494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9496 if (!SWIG_IsOK(res1)) {
9497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9498 }
9499 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9501 if (!SWIG_IsOK(res2)) {
9502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9503 }
9504 if (!argp2) {
9505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9506 }
9507 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 (arg1)->Save(*arg2);
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_Py_Void();
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9522 PyObject *resultobj = 0;
9523 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 PyObject *swig_obj[1] ;
9527
9528 if (!args) SWIG_fail;
9529 swig_obj[0] = args;
9530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9533 }
9534 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9535 {
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 (arg1)->AddFilesToMenu();
9538 wxPyEndAllowThreads(__tstate);
9539 if (PyErr_Occurred()) SWIG_fail;
9540 }
9541 resultobj = SWIG_Py_Void();
9542 return resultobj;
9543 fail:
9544 return NULL;
9545 }
9546
9547
9548 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9549 PyObject *resultobj = 0;
9550 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9551 wxMenu *arg2 = (wxMenu *) 0 ;
9552 void *argp1 = 0 ;
9553 int res1 = 0 ;
9554 void *argp2 = 0 ;
9555 int res2 = 0 ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 char * kwnames[] = {
9559 (char *) "self",(char *) "menu", NULL
9560 };
9561
9562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9564 if (!SWIG_IsOK(res1)) {
9565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9566 }
9567 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9569 if (!SWIG_IsOK(res2)) {
9570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9571 }
9572 arg2 = reinterpret_cast< wxMenu * >(argp2);
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 (arg1)->AddFilesToMenu(arg2);
9576 wxPyEndAllowThreads(__tstate);
9577 if (PyErr_Occurred()) SWIG_fail;
9578 }
9579 resultobj = SWIG_Py_Void();
9580 return resultobj;
9581 fail:
9582 return NULL;
9583 }
9584
9585
9586 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9587 PyObject *resultobj = 0;
9588 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9589 int arg2 ;
9590 wxString result;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 int val2 ;
9594 int ecode2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "i", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9605 }
9606 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9607 ecode2 = SWIG_AsVal_int(obj1, &val2);
9608 if (!SWIG_IsOK(ecode2)) {
9609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9610 }
9611 arg2 = static_cast< int >(val2);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 {
9619 #if wxUSE_UNICODE
9620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9621 #else
9622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9623 #endif
9624 }
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9634 int result;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 result = (int)((wxFileHistory const *)arg1)->GetCount();
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 resultobj = SWIG_From_int(static_cast< int >(result));
9653 return resultobj;
9654 fail:
9655 return NULL;
9656 }
9657
9658
9659 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9660 PyObject *obj;
9661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9662 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9663 return SWIG_Py_Void();
9664 }
9665
9666 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 return SWIG_Python_InitShadowInstance(args);
9668 }
9669
9670 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9671 PyObject *resultobj = 0;
9672 wxString *arg1 = 0 ;
9673 wxString const &arg2_defvalue = wxPyEmptyString ;
9674 wxString *arg2 = (wxString *) &arg2_defvalue ;
9675 wxSingleInstanceChecker *result = 0 ;
9676 bool temp1 = false ;
9677 bool temp2 = false ;
9678 PyObject * obj0 = 0 ;
9679 PyObject * obj1 = 0 ;
9680 char * kwnames[] = {
9681 (char *) "name",(char *) "path", NULL
9682 };
9683
9684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9685 {
9686 arg1 = wxString_in_helper(obj0);
9687 if (arg1 == NULL) SWIG_fail;
9688 temp1 = true;
9689 }
9690 if (obj1) {
9691 {
9692 arg2 = wxString_in_helper(obj1);
9693 if (arg2 == NULL) SWIG_fail;
9694 temp2 = true;
9695 }
9696 }
9697 {
9698 PyThreadState* __tstate = wxPyBeginAllowThreads();
9699 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9700 wxPyEndAllowThreads(__tstate);
9701 if (PyErr_Occurred()) SWIG_fail;
9702 }
9703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9704 {
9705 if (temp1)
9706 delete arg1;
9707 }
9708 {
9709 if (temp2)
9710 delete arg2;
9711 }
9712 return resultobj;
9713 fail:
9714 {
9715 if (temp1)
9716 delete arg1;
9717 }
9718 {
9719 if (temp2)
9720 delete arg2;
9721 }
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727 PyObject *resultobj = 0;
9728 wxSingleInstanceChecker *result = 0 ;
9729
9730 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9756 }
9757 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 delete arg1;
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9775 wxString *arg2 = 0 ;
9776 wxString const &arg3_defvalue = wxPyEmptyString ;
9777 wxString *arg3 = (wxString *) &arg3_defvalue ;
9778 bool result;
9779 void *argp1 = 0 ;
9780 int res1 = 0 ;
9781 bool temp2 = false ;
9782 bool temp3 = false ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char * kwnames[] = {
9787 (char *) "self",(char *) "name",(char *) "path", NULL
9788 };
9789
9790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9792 if (!SWIG_IsOK(res1)) {
9793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9794 }
9795 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9796 {
9797 arg2 = wxString_in_helper(obj1);
9798 if (arg2 == NULL) SWIG_fail;
9799 temp2 = true;
9800 }
9801 if (obj2) {
9802 {
9803 arg3 = wxString_in_helper(obj2);
9804 if (arg3 == NULL) SWIG_fail;
9805 temp3 = true;
9806 }
9807 }
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 {
9815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9816 }
9817 {
9818 if (temp2)
9819 delete arg2;
9820 }
9821 {
9822 if (temp3)
9823 delete arg3;
9824 }
9825 return resultobj;
9826 fail:
9827 {
9828 if (temp2)
9829 delete arg2;
9830 }
9831 {
9832 if (temp3)
9833 delete arg3;
9834 }
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *resultobj = 0;
9841 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9842 bool result;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject *swig_obj[1] ;
9846
9847 if (!args) SWIG_fail;
9848 swig_obj[0] = args;
9849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9850 if (!SWIG_IsOK(res1)) {
9851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9854 {
9855 PyThreadState* __tstate = wxPyBeginAllowThreads();
9856 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9857 wxPyEndAllowThreads(__tstate);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 {
9861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9870 PyObject *obj;
9871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9872 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9873 return SWIG_Py_Void();
9874 }
9875
9876 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9877 return SWIG_Python_InitShadowInstance(args);
9878 }
9879
9880 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = 0;
9882 wxWindow *arg1 = (wxWindow *) 0 ;
9883 wxDC *arg2 = 0 ;
9884 bool result;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 void *argp2 = 0 ;
9888 int res2 = 0 ;
9889 PyObject * obj0 = 0 ;
9890 PyObject * obj1 = 0 ;
9891 char * kwnames[] = {
9892 (char *) "window",(char *) "dc", NULL
9893 };
9894
9895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9897 if (!SWIG_IsOK(res1)) {
9898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9899 }
9900 arg1 = reinterpret_cast< wxWindow * >(argp1);
9901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9902 if (!SWIG_IsOK(res2)) {
9903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9904 }
9905 if (!argp2) {
9906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9907 }
9908 arg2 = reinterpret_cast< wxDC * >(argp2);
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9912 wxPyEndAllowThreads(__tstate);
9913 if (PyErr_Occurred()) SWIG_fail;
9914 }
9915 {
9916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9917 }
9918 return resultobj;
9919 fail:
9920 return NULL;
9921 }
9922
9923
9924 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9925 PyObject *resultobj = 0;
9926 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9927 void *argp1 = 0 ;
9928 int res1 = 0 ;
9929 PyObject *swig_obj[1] ;
9930
9931 if (!args) SWIG_fail;
9932 swig_obj[0] = args;
9933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9934 if (!SWIG_IsOK(res1)) {
9935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9936 }
9937 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 delete arg1;
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_Py_Void();
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 PyObject *resultobj = 0;
9954 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9955 wxString result;
9956 void *argp1 = 0 ;
9957 int res1 = 0 ;
9958 PyObject *swig_obj[1] ;
9959
9960 if (!args) SWIG_fail;
9961 swig_obj[0] = args;
9962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9963 if (!SWIG_IsOK(res1)) {
9964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9965 }
9966 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9967 {
9968 PyThreadState* __tstate = wxPyBeginAllowThreads();
9969 result = (arg1)->GetTip();
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 {
9974 #if wxUSE_UNICODE
9975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9976 #else
9977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9978 #endif
9979 }
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9987 PyObject *resultobj = 0;
9988 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9989 size_t result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 PyObject *swig_obj[1] ;
9993
9994 if (!args) SWIG_fail;
9995 swig_obj[0] = args;
9996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9997 if (!SWIG_IsOK(res1)) {
9998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9999 }
10000 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (size_t)(arg1)->GetCurrentTip();
10004 wxPyEndAllowThreads(__tstate);
10005 if (PyErr_Occurred()) SWIG_fail;
10006 }
10007 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10008 return resultobj;
10009 fail:
10010 return NULL;
10011 }
10012
10013
10014 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10015 PyObject *resultobj = 0;
10016 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10017 wxString *arg2 = 0 ;
10018 wxString result;
10019 void *argp1 = 0 ;
10020 int res1 = 0 ;
10021 bool temp2 = false ;
10022 PyObject * obj0 = 0 ;
10023 PyObject * obj1 = 0 ;
10024 char * kwnames[] = {
10025 (char *) "self",(char *) "tip", NULL
10026 };
10027
10028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10032 }
10033 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10034 {
10035 arg2 = wxString_in_helper(obj1);
10036 if (arg2 == NULL) SWIG_fail;
10037 temp2 = true;
10038 }
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 {
10046 #if wxUSE_UNICODE
10047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10048 #else
10049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10050 #endif
10051 }
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 return resultobj;
10057 fail:
10058 {
10059 if (temp2)
10060 delete arg2;
10061 }
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 PyObject *obj;
10068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10069 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10070 return SWIG_Py_Void();
10071 }
10072
10073 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10074 PyObject *resultobj = 0;
10075 size_t arg1 ;
10076 wxPyTipProvider *result = 0 ;
10077 size_t val1 ;
10078 int ecode1 = 0 ;
10079 PyObject * obj0 = 0 ;
10080 char * kwnames[] = {
10081 (char *) "currentTip", NULL
10082 };
10083
10084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10085 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10086 if (!SWIG_IsOK(ecode1)) {
10087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10088 }
10089 arg1 = static_cast< size_t >(val1);
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10106 PyObject *arg2 = (PyObject *) 0 ;
10107 PyObject *arg3 = (PyObject *) 0 ;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 PyObject * obj2 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "self",(char *) "self",(char *) "_class", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10119 if (!SWIG_IsOK(res1)) {
10120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10121 }
10122 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10123 arg2 = obj1;
10124 arg3 = obj2;
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 (arg1)->_setCallbackInfo(arg2,arg3);
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 resultobj = SWIG_Py_Void();
10132 return resultobj;
10133 fail:
10134 return NULL;
10135 }
10136
10137
10138 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10139 PyObject *obj;
10140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10141 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10142 return SWIG_Py_Void();
10143 }
10144
10145 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10146 return SWIG_Python_InitShadowInstance(args);
10147 }
10148
10149 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10150 PyObject *resultobj = 0;
10151 wxWindow *arg1 = (wxWindow *) 0 ;
10152 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10153 bool arg3 = (bool) true ;
10154 bool result;
10155 void *argp1 = 0 ;
10156 int res1 = 0 ;
10157 void *argp2 = 0 ;
10158 int res2 = 0 ;
10159 bool val3 ;
10160 int ecode3 = 0 ;
10161 PyObject * obj0 = 0 ;
10162 PyObject * obj1 = 0 ;
10163 PyObject * obj2 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10172 }
10173 arg1 = reinterpret_cast< wxWindow * >(argp1);
10174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10175 if (!SWIG_IsOK(res2)) {
10176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10177 }
10178 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10179 if (obj2) {
10180 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10181 if (!SWIG_IsOK(ecode3)) {
10182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10183 }
10184 arg3 = static_cast< bool >(val3);
10185 }
10186 {
10187 if (!wxPyCheckForApp()) SWIG_fail;
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (bool)wxShowTip(arg1,arg2,arg3);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10195 }
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj = 0;
10204 wxString *arg1 = 0 ;
10205 size_t arg2 ;
10206 wxTipProvider *result = 0 ;
10207 bool temp1 = false ;
10208 size_t val2 ;
10209 int ecode2 = 0 ;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 char * kwnames[] = {
10213 (char *) "filename",(char *) "currentTip", NULL
10214 };
10215
10216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10217 {
10218 arg1 = wxString_in_helper(obj0);
10219 if (arg1 == NULL) SWIG_fail;
10220 temp1 = true;
10221 }
10222 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10223 if (!SWIG_IsOK(ecode2)) {
10224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10225 }
10226 arg2 = static_cast< size_t >(val2);
10227 {
10228 if (!wxPyCheckForApp()) SWIG_fail;
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return resultobj;
10240 fail:
10241 {
10242 if (temp1)
10243 delete arg1;
10244 }
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10252 int arg2 = (int) wxID_ANY ;
10253 wxPyTimer *result = 0 ;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 int val2 ;
10257 int ecode2 = 0 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "owner",(char *) "id", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10265 if (obj0) {
10266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10267 if (!SWIG_IsOK(res1)) {
10268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10269 }
10270 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10271 }
10272 if (obj1) {
10273 ecode2 = SWIG_AsVal_int(obj1, &val2);
10274 if (!SWIG_IsOK(ecode2)) {
10275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10276 }
10277 arg2 = static_cast< int >(val2);
10278 }
10279 {
10280 if (!wxPyCheckForApp()) SWIG_fail;
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10287 return resultobj;
10288 fail:
10289 return NULL;
10290 }
10291
10292
10293 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10296 void *argp1 = 0 ;
10297 int res1 = 0 ;
10298 PyObject *swig_obj[1] ;
10299
10300 if (!args) SWIG_fail;
10301 swig_obj[0] = args;
10302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10305 }
10306 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10307 {
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 delete arg1;
10310
10311 wxPyEndAllowThreads(__tstate);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_Py_Void();
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj = 0;
10323 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10324 PyObject *arg2 = (PyObject *) 0 ;
10325 PyObject *arg3 = (PyObject *) 0 ;
10326 int arg4 = (int) 1 ;
10327 void *argp1 = 0 ;
10328 int res1 = 0 ;
10329 int val4 ;
10330 int ecode4 = 0 ;
10331 PyObject * obj0 = 0 ;
10332 PyObject * obj1 = 0 ;
10333 PyObject * obj2 = 0 ;
10334 PyObject * obj3 = 0 ;
10335 char * kwnames[] = {
10336 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10337 };
10338
10339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10341 if (!SWIG_IsOK(res1)) {
10342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10343 }
10344 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10345 arg2 = obj1;
10346 arg3 = obj2;
10347 if (obj3) {
10348 ecode4 = SWIG_AsVal_int(obj3, &val4);
10349 if (!SWIG_IsOK(ecode4)) {
10350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10351 }
10352 arg4 = static_cast< int >(val4);
10353 }
10354 {
10355 PyThreadState* __tstate = wxPyBeginAllowThreads();
10356 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10357 wxPyEndAllowThreads(__tstate);
10358 if (PyErr_Occurred()) SWIG_fail;
10359 }
10360 resultobj = SWIG_Py_Void();
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj = 0;
10369 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10370 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10371 int arg3 = (int) wxID_ANY ;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 void *argp2 = 0 ;
10375 int res2 = 0 ;
10376 int val3 ;
10377 int ecode3 = 0 ;
10378 PyObject * obj0 = 0 ;
10379 PyObject * obj1 = 0 ;
10380 PyObject * obj2 = 0 ;
10381 char * kwnames[] = {
10382 (char *) "self",(char *) "owner",(char *) "id", NULL
10383 };
10384
10385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10387 if (!SWIG_IsOK(res1)) {
10388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10389 }
10390 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10392 if (!SWIG_IsOK(res2)) {
10393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10394 }
10395 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10396 if (obj2) {
10397 ecode3 = SWIG_AsVal_int(obj2, &val3);
10398 if (!SWIG_IsOK(ecode3)) {
10399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10400 }
10401 arg3 = static_cast< int >(val3);
10402 }
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 (arg1)->SetOwner(arg2,arg3);
10406 wxPyEndAllowThreads(__tstate);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 resultobj = SWIG_Py_Void();
10410 return resultobj;
10411 fail:
10412 return NULL;
10413 }
10414
10415
10416 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10417 PyObject *resultobj = 0;
10418 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10419 wxEvtHandler *result = 0 ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 PyObject *swig_obj[1] ;
10423
10424 if (!args) SWIG_fail;
10425 swig_obj[0] = args;
10426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (wxEvtHandler *)(arg1)->GetOwner();
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 resultobj = wxPyMake_wxObject(result, 0);
10439 }
10440 return resultobj;
10441 fail:
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj = 0;
10448 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10449 int arg2 = (int) -1 ;
10450 bool arg3 = (bool) false ;
10451 bool result;
10452 void *argp1 = 0 ;
10453 int res1 = 0 ;
10454 int val2 ;
10455 int ecode2 = 0 ;
10456 bool val3 ;
10457 int ecode3 = 0 ;
10458 PyObject * obj0 = 0 ;
10459 PyObject * obj1 = 0 ;
10460 PyObject * obj2 = 0 ;
10461 char * kwnames[] = {
10462 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10463 };
10464
10465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10469 }
10470 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10471 if (obj1) {
10472 ecode2 = SWIG_AsVal_int(obj1, &val2);
10473 if (!SWIG_IsOK(ecode2)) {
10474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10475 }
10476 arg2 = static_cast< int >(val2);
10477 }
10478 if (obj2) {
10479 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10480 if (!SWIG_IsOK(ecode3)) {
10481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10482 }
10483 arg3 = static_cast< bool >(val3);
10484 }
10485 {
10486 PyThreadState* __tstate = wxPyBeginAllowThreads();
10487 result = (bool)(arg1)->Start(arg2,arg3);
10488 wxPyEndAllowThreads(__tstate);
10489 if (PyErr_Occurred()) SWIG_fail;
10490 }
10491 {
10492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10493 }
10494 return resultobj;
10495 fail:
10496 return NULL;
10497 }
10498
10499
10500 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10501 PyObject *resultobj = 0;
10502 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10503 void *argp1 = 0 ;
10504 int res1 = 0 ;
10505 PyObject *swig_obj[1] ;
10506
10507 if (!args) SWIG_fail;
10508 swig_obj[0] = args;
10509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10512 }
10513 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 (arg1)->Stop();
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 resultobj = SWIG_Py_Void();
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10528 PyObject *resultobj = 0;
10529 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10530 void *argp1 = 0 ;
10531 int res1 = 0 ;
10532 PyObject *swig_obj[1] ;
10533
10534 if (!args) SWIG_fail;
10535 swig_obj[0] = args;
10536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10537 if (!SWIG_IsOK(res1)) {
10538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10539 }
10540 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 (arg1)->Notify();
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 resultobj = SWIG_Py_Void();
10548 return resultobj;
10549 fail:
10550 return NULL;
10551 }
10552
10553
10554 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10555 PyObject *resultobj = 0;
10556 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10557 bool result;
10558 void *argp1 = 0 ;
10559 int res1 = 0 ;
10560 PyObject *swig_obj[1] ;
10561
10562 if (!args) SWIG_fail;
10563 swig_obj[0] = args;
10564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10565 if (!SWIG_IsOK(res1)) {
10566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10567 }
10568 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10569 {
10570 PyThreadState* __tstate = wxPyBeginAllowThreads();
10571 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 {
10576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10585 PyObject *resultobj = 0;
10586 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10587 int result;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 PyObject *swig_obj[1] ;
10591
10592 if (!args) SWIG_fail;
10593 swig_obj[0] = args;
10594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10595 if (!SWIG_IsOK(res1)) {
10596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10597 }
10598 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 resultobj = SWIG_From_int(static_cast< int >(result));
10606 return resultobj;
10607 fail:
10608 return NULL;
10609 }
10610
10611
10612 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10613 PyObject *resultobj = 0;
10614 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10615 int result;
10616 void *argp1 = 0 ;
10617 int res1 = 0 ;
10618 PyObject *swig_obj[1] ;
10619
10620 if (!args) SWIG_fail;
10621 swig_obj[0] = args;
10622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10623 if (!SWIG_IsOK(res1)) {
10624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10625 }
10626 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (int)((wxPyTimer const *)arg1)->GetId();
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 resultobj = SWIG_From_int(static_cast< int >(result));
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10641 PyObject *resultobj = 0;
10642 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10643 bool result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 PyObject *swig_obj[1] ;
10647
10648 if (!args) SWIG_fail;
10649 swig_obj[0] = args;
10650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10653 }
10654 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10658 wxPyEndAllowThreads(__tstate);
10659 if (PyErr_Occurred()) SWIG_fail;
10660 }
10661 {
10662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10663 }
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10671 PyObject *obj;
10672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10673 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10674 return SWIG_Py_Void();
10675 }
10676
10677 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10678 return SWIG_Python_InitShadowInstance(args);
10679 }
10680
10681 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj = 0;
10683 int arg1 = (int) 0 ;
10684 int arg2 = (int) 0 ;
10685 wxTimerEvent *result = 0 ;
10686 int val1 ;
10687 int ecode1 = 0 ;
10688 int val2 ;
10689 int ecode2 = 0 ;
10690 PyObject * obj0 = 0 ;
10691 PyObject * obj1 = 0 ;
10692 char * kwnames[] = {
10693 (char *) "timerid",(char *) "interval", NULL
10694 };
10695
10696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10697 if (obj0) {
10698 ecode1 = SWIG_AsVal_int(obj0, &val1);
10699 if (!SWIG_IsOK(ecode1)) {
10700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10701 }
10702 arg1 = static_cast< int >(val1);
10703 }
10704 if (obj1) {
10705 ecode2 = SWIG_AsVal_int(obj1, &val2);
10706 if (!SWIG_IsOK(ecode2)) {
10707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10708 }
10709 arg2 = static_cast< int >(val2);
10710 }
10711 {
10712 PyThreadState* __tstate = wxPyBeginAllowThreads();
10713 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10718 return resultobj;
10719 fail:
10720 return NULL;
10721 }
10722
10723
10724 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10725 PyObject *resultobj = 0;
10726 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10727 int result;
10728 void *argp1 = 0 ;
10729 int res1 = 0 ;
10730 PyObject *swig_obj[1] ;
10731
10732 if (!args) SWIG_fail;
10733 swig_obj[0] = args;
10734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10735 if (!SWIG_IsOK(res1)) {
10736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10737 }
10738 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 resultobj = SWIG_From_int(static_cast< int >(result));
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10753 PyObject *obj;
10754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10755 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10756 return SWIG_Py_Void();
10757 }
10758
10759 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10760 return SWIG_Python_InitShadowInstance(args);
10761 }
10762
10763 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10764 PyObject *resultobj = 0;
10765 wxTimer *arg1 = 0 ;
10766 wxTimerRunner *result = 0 ;
10767 void *argp1 = 0 ;
10768 int res1 = 0 ;
10769
10770 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10772 if (!SWIG_IsOK(res1)) {
10773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10774 }
10775 if (!argp1) {
10776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10777 }
10778 arg1 = reinterpret_cast< wxTimer * >(argp1);
10779 {
10780 if (!wxPyCheckForApp()) SWIG_fail;
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10794 PyObject *resultobj = 0;
10795 wxTimer *arg1 = 0 ;
10796 int arg2 ;
10797 bool arg3 = (bool) false ;
10798 wxTimerRunner *result = 0 ;
10799 void *argp1 = 0 ;
10800 int res1 = 0 ;
10801 int val2 ;
10802 int ecode2 = 0 ;
10803 bool val3 ;
10804 int ecode3 = 0 ;
10805
10806 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10808 if (!SWIG_IsOK(res1)) {
10809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10810 }
10811 if (!argp1) {
10812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10813 }
10814 arg1 = reinterpret_cast< wxTimer * >(argp1);
10815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10816 if (!SWIG_IsOK(ecode2)) {
10817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10818 }
10819 arg2 = static_cast< int >(val2);
10820 if (swig_obj[2]) {
10821 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10822 if (!SWIG_IsOK(ecode3)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10824 }
10825 arg3 = static_cast< bool >(val3);
10826 }
10827 {
10828 if (!wxPyCheckForApp()) SWIG_fail;
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10835 return resultobj;
10836 fail:
10837 return NULL;
10838 }
10839
10840
10841 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10842 int argc;
10843 PyObject *argv[4];
10844
10845 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10846 --argc;
10847 if (argc == 1) {
10848 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10849 }
10850 if ((argc >= 2) && (argc <= 3)) {
10851 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10852 }
10853
10854 fail:
10855 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10856 return NULL;
10857 }
10858
10859
10860 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10861 PyObject *resultobj = 0;
10862 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10863 void *argp1 = 0 ;
10864 int res1 = 0 ;
10865 PyObject *swig_obj[1] ;
10866
10867 if (!args) SWIG_fail;
10868 swig_obj[0] = args;
10869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10870 if (!SWIG_IsOK(res1)) {
10871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10872 }
10873 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 delete arg1;
10877
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_Py_Void();
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10891 int arg2 ;
10892 bool arg3 = (bool) false ;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 int val2 ;
10896 int ecode2 = 0 ;
10897 bool val3 ;
10898 int ecode3 = 0 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 PyObject * obj2 = 0 ;
10902 char * kwnames[] = {
10903 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10904 };
10905
10906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10908 if (!SWIG_IsOK(res1)) {
10909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10910 }
10911 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10912 ecode2 = SWIG_AsVal_int(obj1, &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 if (obj2) {
10918 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10919 if (!SWIG_IsOK(ecode3)) {
10920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10921 }
10922 arg3 = static_cast< bool >(val3);
10923 }
10924 {
10925 PyThreadState* __tstate = wxPyBeginAllowThreads();
10926 (arg1)->Start(arg2,arg3);
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 resultobj = SWIG_Py_Void();
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10938 PyObject *obj;
10939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10940 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10941 return SWIG_Py_Void();
10942 }
10943
10944 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 return SWIG_Python_InitShadowInstance(args);
10946 }
10947
10948 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10949 PyObject *resultobj = 0;
10950 wxLog *result = 0 ;
10951
10952 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 result = (wxLog *)new wxLog();
10956 wxPyEndAllowThreads(__tstate);
10957 if (PyErr_Occurred()) SWIG_fail;
10958 }
10959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10960 return resultobj;
10961 fail:
10962 return NULL;
10963 }
10964
10965
10966 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10967 PyObject *resultobj = 0;
10968 wxLog *arg1 = (wxLog *) 0 ;
10969 void *argp1 = 0 ;
10970 int res1 = 0 ;
10971 PyObject *swig_obj[1] ;
10972
10973 if (!args) SWIG_fail;
10974 swig_obj[0] = args;
10975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10976 if (!SWIG_IsOK(res1)) {
10977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10978 }
10979 arg1 = reinterpret_cast< wxLog * >(argp1);
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 delete arg1;
10983
10984 wxPyEndAllowThreads(__tstate);
10985 if (PyErr_Occurred()) SWIG_fail;
10986 }
10987 resultobj = SWIG_Py_Void();
10988 return resultobj;
10989 fail:
10990 return NULL;
10991 }
10992
10993
10994 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10995 PyObject *resultobj = 0;
10996 bool result;
10997
10998 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (bool)wxLog::IsEnabled();
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj = 0;
11016 bool arg1 = (bool) true ;
11017 bool result;
11018 bool val1 ;
11019 int ecode1 = 0 ;
11020 PyObject * obj0 = 0 ;
11021 char * kwnames[] = {
11022 (char *) "doIt", NULL
11023 };
11024
11025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11026 if (obj0) {
11027 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11028 if (!SWIG_IsOK(ecode1)) {
11029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11030 }
11031 arg1 = static_cast< bool >(val1);
11032 }
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (bool)wxLog::EnableLogging(arg1);
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11041 }
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj = 0;
11050 wxLogLevel arg1 ;
11051 wxChar *arg2 = (wxChar *) 0 ;
11052 time_t arg3 ;
11053 unsigned long val1 ;
11054 int ecode1 = 0 ;
11055 void *argp2 = 0 ;
11056 int res2 = 0 ;
11057 unsigned int val3 ;
11058 int ecode3 = 0 ;
11059 PyObject * obj0 = 0 ;
11060 PyObject * obj1 = 0 ;
11061 PyObject * obj2 = 0 ;
11062 char * kwnames[] = {
11063 (char *) "level",(char *) "szString",(char *) "t", NULL
11064 };
11065
11066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11067 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11068 if (!SWIG_IsOK(ecode1)) {
11069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11070 }
11071 arg1 = static_cast< wxLogLevel >(val1);
11072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11073 if (!SWIG_IsOK(res2)) {
11074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11075 }
11076 arg2 = reinterpret_cast< wxChar * >(argp2);
11077 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11078 if (!SWIG_IsOK(ecode3)) {
11079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11080 }
11081 arg3 = static_cast< time_t >(val3);
11082 {
11083 PyThreadState* __tstate = wxPyBeginAllowThreads();
11084 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11085 wxPyEndAllowThreads(__tstate);
11086 if (PyErr_Occurred()) SWIG_fail;
11087 }
11088 resultobj = SWIG_Py_Void();
11089 return resultobj;
11090 fail:
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11096 PyObject *resultobj = 0;
11097 wxLog *arg1 = (wxLog *) 0 ;
11098 void *argp1 = 0 ;
11099 int res1 = 0 ;
11100 PyObject *swig_obj[1] ;
11101
11102 if (!args) SWIG_fail;
11103 swig_obj[0] = args;
11104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11105 if (!SWIG_IsOK(res1)) {
11106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11107 }
11108 arg1 = reinterpret_cast< wxLog * >(argp1);
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 (arg1)->Flush();
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 resultobj = SWIG_Py_Void();
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11123 PyObject *resultobj = 0;
11124
11125 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 wxLog::FlushActive();
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 resultobj = SWIG_Py_Void();
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxLog *result = 0 ;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (wxLog *)wxLog::GetActiveTarget();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = 0;
11159 wxLog *arg1 = (wxLog *) 0 ;
11160 wxLog *result = 0 ;
11161 int res1 = 0 ;
11162 PyObject * obj0 = 0 ;
11163 char * kwnames[] = {
11164 (char *) "pLogger", NULL
11165 };
11166
11167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11168 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11169 if (!SWIG_IsOK(res1)) {
11170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11171 }
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *resultobj = 0;
11187
11188 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 wxLog::Suspend();
11192 wxPyEndAllowThreads(__tstate);
11193 if (PyErr_Occurred()) SWIG_fail;
11194 }
11195 resultobj = SWIG_Py_Void();
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11203 PyObject *resultobj = 0;
11204
11205 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 wxLog::Resume();
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 resultobj = SWIG_Py_Void();
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11220 PyObject *resultobj = 0;
11221 bool arg1 = (bool) true ;
11222 bool val1 ;
11223 int ecode1 = 0 ;
11224 PyObject * obj0 = 0 ;
11225 char * kwnames[] = {
11226 (char *) "bVerbose", NULL
11227 };
11228
11229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11230 if (obj0) {
11231 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11232 if (!SWIG_IsOK(ecode1)) {
11233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11234 }
11235 arg1 = static_cast< bool >(val1);
11236 }
11237 {
11238 PyThreadState* __tstate = wxPyBeginAllowThreads();
11239 wxLog::SetVerbose(arg1);
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 resultobj = SWIG_Py_Void();
11244 return resultobj;
11245 fail:
11246 return NULL;
11247 }
11248
11249
11250 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11251 PyObject *resultobj = 0;
11252 wxLogLevel arg1 ;
11253 unsigned long val1 ;
11254 int ecode1 = 0 ;
11255 PyObject * obj0 = 0 ;
11256 char * kwnames[] = {
11257 (char *) "logLevel", NULL
11258 };
11259
11260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11261 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11262 if (!SWIG_IsOK(ecode1)) {
11263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11264 }
11265 arg1 = static_cast< wxLogLevel >(val1);
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 wxLog::SetLogLevel(arg1);
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 resultobj = SWIG_Py_Void();
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280 PyObject *resultobj = 0;
11281
11282 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11283 {
11284 PyThreadState* __tstate = wxPyBeginAllowThreads();
11285 wxLog::DontCreateOnDemand();
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 resultobj = SWIG_Py_Void();
11290 return resultobj;
11291 fail:
11292 return NULL;
11293 }
11294
11295
11296 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj = 0;
11298 wxTraceMask arg1 ;
11299 unsigned long val1 ;
11300 int ecode1 = 0 ;
11301 PyObject * obj0 = 0 ;
11302 char * kwnames[] = {
11303 (char *) "ulMask", NULL
11304 };
11305
11306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11307 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11308 if (!SWIG_IsOK(ecode1)) {
11309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11310 }
11311 arg1 = static_cast< wxTraceMask >(val1);
11312 {
11313 PyThreadState* __tstate = wxPyBeginAllowThreads();
11314 wxLog::SetTraceMask(arg1);
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 resultobj = SWIG_Py_Void();
11319 return resultobj;
11320 fail:
11321 return NULL;
11322 }
11323
11324
11325 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11326 PyObject *resultobj = 0;
11327 wxString *arg1 = 0 ;
11328 bool temp1 = false ;
11329 PyObject * obj0 = 0 ;
11330 char * kwnames[] = {
11331 (char *) "str", NULL
11332 };
11333
11334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11335 {
11336 arg1 = wxString_in_helper(obj0);
11337 if (arg1 == NULL) SWIG_fail;
11338 temp1 = true;
11339 }
11340 {
11341 PyThreadState* __tstate = wxPyBeginAllowThreads();
11342 wxLog::AddTraceMask((wxString const &)*arg1);
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_Py_Void();
11347 {
11348 if (temp1)
11349 delete arg1;
11350 }
11351 return resultobj;
11352 fail:
11353 {
11354 if (temp1)
11355 delete arg1;
11356 }
11357 return NULL;
11358 }
11359
11360
11361 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj = 0;
11363 wxString *arg1 = 0 ;
11364 bool temp1 = false ;
11365 PyObject * obj0 = 0 ;
11366 char * kwnames[] = {
11367 (char *) "str", NULL
11368 };
11369
11370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11371 {
11372 arg1 = wxString_in_helper(obj0);
11373 if (arg1 == NULL) SWIG_fail;
11374 temp1 = true;
11375 }
11376 {
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 wxLog::RemoveTraceMask((wxString const &)*arg1);
11379 wxPyEndAllowThreads(__tstate);
11380 if (PyErr_Occurred()) SWIG_fail;
11381 }
11382 resultobj = SWIG_Py_Void();
11383 {
11384 if (temp1)
11385 delete arg1;
11386 }
11387 return resultobj;
11388 fail:
11389 {
11390 if (temp1)
11391 delete arg1;
11392 }
11393 return NULL;
11394 }
11395
11396
11397 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 PyObject *resultobj = 0;
11399
11400 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 wxLog::ClearTraceMasks();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 resultobj = SWIG_Py_Void();
11408 return resultobj;
11409 fail:
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11415 PyObject *resultobj = 0;
11416 wxArrayString *result = 0 ;
11417
11418 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 {
11422 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11423 result = (wxArrayString *) &_result_ref;
11424 }
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 {
11429 resultobj = wxArrayString2PyList_helper(*result);
11430 }
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj = 0;
11439 wxChar *arg1 = (wxChar *) 0 ;
11440 void *argp1 = 0 ;
11441 int res1 = 0 ;
11442 PyObject * obj0 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "ts", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11449 if (!SWIG_IsOK(res1)) {
11450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11451 }
11452 arg1 = reinterpret_cast< wxChar * >(argp1);
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 wxLog::SetTimestamp((wxChar const *)arg1);
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11467 PyObject *resultobj = 0;
11468 bool result;
11469
11470 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11471 {
11472 PyThreadState* __tstate = wxPyBeginAllowThreads();
11473 result = (bool)wxLog::GetVerbose();
11474 wxPyEndAllowThreads(__tstate);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 {
11478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11479 }
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11487 PyObject *resultobj = 0;
11488 wxTraceMask result;
11489
11490 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (wxTraceMask)wxLog::GetTraceMask();
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj = 0;
11506 wxChar *arg1 = (wxChar *) 0 ;
11507 bool result;
11508 void *argp1 = 0 ;
11509 int res1 = 0 ;
11510 PyObject * obj0 = 0 ;
11511 char * kwnames[] = {
11512 (char *) "mask", NULL
11513 };
11514
11515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11519 }
11520 arg1 = reinterpret_cast< wxChar * >(argp1);
11521 {
11522 PyThreadState* __tstate = wxPyBeginAllowThreads();
11523 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11524 wxPyEndAllowThreads(__tstate);
11525 if (PyErr_Occurred()) SWIG_fail;
11526 }
11527 {
11528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11529 }
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537 PyObject *resultobj = 0;
11538 wxLogLevel result;
11539
11540 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 result = (wxLogLevel)wxLog::GetLogLevel();
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11555 PyObject *resultobj = 0;
11556 wxChar *result = 0 ;
11557
11558 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (wxChar *)wxLog::GetTimestamp();
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11566 return resultobj;
11567 fail:
11568 return NULL;
11569 }
11570
11571
11572 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 wxString result;
11575
11576 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = wxLog_TimeStamp();
11580 wxPyEndAllowThreads(__tstate);
11581 if (PyErr_Occurred()) SWIG_fail;
11582 }
11583 {
11584 #if wxUSE_UNICODE
11585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11586 #else
11587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11588 #endif
11589 }
11590 return resultobj;
11591 fail:
11592 return NULL;
11593 }
11594
11595
11596 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11597 PyObject *resultobj = 0;
11598 wxLog *arg1 = (wxLog *) 0 ;
11599 void *argp1 = 0 ;
11600 int res1 = 0 ;
11601 PyObject *swig_obj[1] ;
11602
11603 if (!args) SWIG_fail;
11604 swig_obj[0] = args;
11605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11606 if (!SWIG_IsOK(res1)) {
11607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11608 }
11609 arg1 = reinterpret_cast< wxLog * >(argp1);
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 wxLog_Destroy(arg1);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 resultobj = SWIG_Py_Void();
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *obj;
11625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11626 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11627 return SWIG_Py_Void();
11628 }
11629
11630 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631 return SWIG_Python_InitShadowInstance(args);
11632 }
11633
11634 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11635 PyObject *resultobj = 0;
11636 wxLogStderr *result = 0 ;
11637
11638 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (wxLogStderr *)new wxLogStderr();
11642 wxPyEndAllowThreads(__tstate);
11643 if (PyErr_Occurred()) SWIG_fail;
11644 }
11645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11653 PyObject *obj;
11654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11655 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11656 return SWIG_Py_Void();
11657 }
11658
11659 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11660 return SWIG_Python_InitShadowInstance(args);
11661 }
11662
11663 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj = 0;
11665 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11666 wxLogTextCtrl *result = 0 ;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 PyObject * obj0 = 0 ;
11670 char * kwnames[] = {
11671 (char *) "pTextCtrl", NULL
11672 };
11673
11674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11678 }
11679 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11680 {
11681 PyThreadState* __tstate = wxPyBeginAllowThreads();
11682 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11683 wxPyEndAllowThreads(__tstate);
11684 if (PyErr_Occurred()) SWIG_fail;
11685 }
11686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *obj;
11695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11696 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11697 return SWIG_Py_Void();
11698 }
11699
11700 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11701 return SWIG_Python_InitShadowInstance(args);
11702 }
11703
11704 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11705 PyObject *resultobj = 0;
11706 wxLogGui *result = 0 ;
11707
11708 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (wxLogGui *)new wxLogGui();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *obj;
11724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11725 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11726 return SWIG_Py_Void();
11727 }
11728
11729 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 return SWIG_Python_InitShadowInstance(args);
11731 }
11732
11733 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj = 0;
11735 wxFrame *arg1 = (wxFrame *) 0 ;
11736 wxString *arg2 = 0 ;
11737 bool arg3 = (bool) true ;
11738 bool arg4 = (bool) true ;
11739 wxLogWindow *result = 0 ;
11740 void *argp1 = 0 ;
11741 int res1 = 0 ;
11742 bool temp2 = false ;
11743 bool val3 ;
11744 int ecode3 = 0 ;
11745 bool val4 ;
11746 int ecode4 = 0 ;
11747 PyObject * obj0 = 0 ;
11748 PyObject * obj1 = 0 ;
11749 PyObject * obj2 = 0 ;
11750 PyObject * obj3 = 0 ;
11751 char * kwnames[] = {
11752 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11753 };
11754
11755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11757 if (!SWIG_IsOK(res1)) {
11758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11759 }
11760 arg1 = reinterpret_cast< wxFrame * >(argp1);
11761 {
11762 arg2 = wxString_in_helper(obj1);
11763 if (arg2 == NULL) SWIG_fail;
11764 temp2 = true;
11765 }
11766 if (obj2) {
11767 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11768 if (!SWIG_IsOK(ecode3)) {
11769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11770 }
11771 arg3 = static_cast< bool >(val3);
11772 }
11773 if (obj3) {
11774 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11775 if (!SWIG_IsOK(ecode4)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11777 }
11778 arg4 = static_cast< bool >(val4);
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11787 {
11788 if (temp2)
11789 delete arg2;
11790 }
11791 return resultobj;
11792 fail:
11793 {
11794 if (temp2)
11795 delete arg2;
11796 }
11797 return NULL;
11798 }
11799
11800
11801 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj = 0;
11803 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11804 bool arg2 = (bool) true ;
11805 void *argp1 = 0 ;
11806 int res1 = 0 ;
11807 bool val2 ;
11808 int ecode2 = 0 ;
11809 PyObject * obj0 = 0 ;
11810 PyObject * obj1 = 0 ;
11811 char * kwnames[] = {
11812 (char *) "self",(char *) "bShow", NULL
11813 };
11814
11815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11819 }
11820 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11821 if (obj1) {
11822 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11823 if (!SWIG_IsOK(ecode2)) {
11824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11825 }
11826 arg2 = static_cast< bool >(val2);
11827 }
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 (arg1)->Show(arg2);
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 resultobj = SWIG_Py_Void();
11835 return resultobj;
11836 fail:
11837 return NULL;
11838 }
11839
11840
11841 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11842 PyObject *resultobj = 0;
11843 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11844 wxFrame *result = 0 ;
11845 void *argp1 = 0 ;
11846 int res1 = 0 ;
11847 PyObject *swig_obj[1] ;
11848
11849 if (!args) SWIG_fail;
11850 swig_obj[0] = args;
11851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11852 if (!SWIG_IsOK(res1)) {
11853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11854 }
11855 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11856 {
11857 PyThreadState* __tstate = wxPyBeginAllowThreads();
11858 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 resultobj = wxPyMake_wxObject(result, (bool)0);
11864 }
11865 return resultobj;
11866 fail:
11867 return NULL;
11868 }
11869
11870
11871 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11872 PyObject *resultobj = 0;
11873 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11874 wxLog *result = 0 ;
11875 void *argp1 = 0 ;
11876 int res1 = 0 ;
11877 PyObject *swig_obj[1] ;
11878
11879 if (!args) SWIG_fail;
11880 swig_obj[0] = args;
11881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11882 if (!SWIG_IsOK(res1)) {
11883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11884 }
11885 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11889 wxPyEndAllowThreads(__tstate);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11900 PyObject *resultobj = 0;
11901 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11902 bool result;
11903 void *argp1 = 0 ;
11904 int res1 = 0 ;
11905 PyObject *swig_obj[1] ;
11906
11907 if (!args) SWIG_fail;
11908 swig_obj[0] = args;
11909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11910 if (!SWIG_IsOK(res1)) {
11911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11912 }
11913 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 {
11921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11922 }
11923 return resultobj;
11924 fail:
11925 return NULL;
11926 }
11927
11928
11929 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj = 0;
11931 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11932 bool arg2 ;
11933 void *argp1 = 0 ;
11934 int res1 = 0 ;
11935 bool val2 ;
11936 int ecode2 = 0 ;
11937 PyObject * obj0 = 0 ;
11938 PyObject * obj1 = 0 ;
11939 char * kwnames[] = {
11940 (char *) "self",(char *) "bDoPass", NULL
11941 };
11942
11943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11945 if (!SWIG_IsOK(res1)) {
11946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11947 }
11948 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11950 if (!SWIG_IsOK(ecode2)) {
11951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11952 }
11953 arg2 = static_cast< bool >(val2);
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 (arg1)->PassMessages(arg2);
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 resultobj = SWIG_Py_Void();
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968 PyObject *obj;
11969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11970 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11971 return SWIG_Py_Void();
11972 }
11973
11974 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11975 return SWIG_Python_InitShadowInstance(args);
11976 }
11977
11978 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11979 PyObject *resultobj = 0;
11980 wxLog *arg1 = (wxLog *) 0 ;
11981 wxLogChain *result = 0 ;
11982 void *argp1 = 0 ;
11983 int res1 = 0 ;
11984 PyObject * obj0 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "logger", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11993 }
11994 arg1 = reinterpret_cast< wxLog * >(argp1);
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 result = (wxLogChain *)new wxLogChain(arg1);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12009 PyObject *resultobj = 0;
12010 wxLogChain *arg1 = (wxLogChain *) 0 ;
12011 wxLog *arg2 = (wxLog *) 0 ;
12012 void *argp1 = 0 ;
12013 int res1 = 0 ;
12014 void *argp2 = 0 ;
12015 int res2 = 0 ;
12016 PyObject * obj0 = 0 ;
12017 PyObject * obj1 = 0 ;
12018 char * kwnames[] = {
12019 (char *) "self",(char *) "logger", NULL
12020 };
12021
12022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12024 if (!SWIG_IsOK(res1)) {
12025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12026 }
12027 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12029 if (!SWIG_IsOK(res2)) {
12030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12031 }
12032 arg2 = reinterpret_cast< wxLog * >(argp2);
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 (arg1)->SetLog(arg2);
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 resultobj = SWIG_Py_Void();
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12047 PyObject *resultobj = 0;
12048 wxLogChain *arg1 = (wxLogChain *) 0 ;
12049 bool arg2 ;
12050 void *argp1 = 0 ;
12051 int res1 = 0 ;
12052 bool val2 ;
12053 int ecode2 = 0 ;
12054 PyObject * obj0 = 0 ;
12055 PyObject * obj1 = 0 ;
12056 char * kwnames[] = {
12057 (char *) "self",(char *) "bDoPass", NULL
12058 };
12059
12060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12062 if (!SWIG_IsOK(res1)) {
12063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12064 }
12065 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12066 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12067 if (!SWIG_IsOK(ecode2)) {
12068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12069 }
12070 arg2 = static_cast< bool >(val2);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 (arg1)->PassMessages(arg2);
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_Py_Void();
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *resultobj = 0;
12086 wxLogChain *arg1 = (wxLogChain *) 0 ;
12087 bool result;
12088 void *argp1 = 0 ;
12089 int res1 = 0 ;
12090 PyObject *swig_obj[1] ;
12091
12092 if (!args) SWIG_fail;
12093 swig_obj[0] = args;
12094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12095 if (!SWIG_IsOK(res1)) {
12096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12097 }
12098 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = (bool)(arg1)->IsPassingMessages();
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12107 }
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12115 PyObject *resultobj = 0;
12116 wxLogChain *arg1 = (wxLogChain *) 0 ;
12117 wxLog *result = 0 ;
12118 void *argp1 = 0 ;
12119 int res1 = 0 ;
12120 PyObject *swig_obj[1] ;
12121
12122 if (!args) SWIG_fail;
12123 swig_obj[0] = args;
12124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12125 if (!SWIG_IsOK(res1)) {
12126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12127 }
12128 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12129 {
12130 PyThreadState* __tstate = wxPyBeginAllowThreads();
12131 result = (wxLog *)(arg1)->GetOldLog();
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12143 PyObject *obj;
12144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12145 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12146 return SWIG_Py_Void();
12147 }
12148
12149 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12150 return SWIG_Python_InitShadowInstance(args);
12151 }
12152
12153 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 PyObject *resultobj = 0;
12155 wxLogBuffer *result = 0 ;
12156
12157 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (wxLogBuffer *)new wxLogBuffer();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *resultobj = 0;
12173 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12174 wxString *result = 0 ;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject *swig_obj[1] ;
12178
12179 if (!args) SWIG_fail;
12180 swig_obj[0] = args;
12181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12182 if (!SWIG_IsOK(res1)) {
12183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12184 }
12185 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 {
12189 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12190 result = (wxString *) &_result_ref;
12191 }
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 {
12196 #if wxUSE_UNICODE
12197 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12198 #else
12199 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12200 #endif
12201 }
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 PyObject *obj;
12210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12211 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12212 return SWIG_Py_Void();
12213 }
12214
12215 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12216 return SWIG_Python_InitShadowInstance(args);
12217 }
12218
12219 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12220 PyObject *resultobj = 0;
12221 unsigned long result;
12222
12223 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 result = (unsigned long)wxSysErrorCode();
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj = 0;
12239 unsigned long arg1 = (unsigned long) 0 ;
12240 wxString result;
12241 unsigned long val1 ;
12242 int ecode1 = 0 ;
12243 PyObject * obj0 = 0 ;
12244 char * kwnames[] = {
12245 (char *) "nErrCode", NULL
12246 };
12247
12248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12249 if (obj0) {
12250 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12251 if (!SWIG_IsOK(ecode1)) {
12252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12253 }
12254 arg1 = static_cast< unsigned long >(val1);
12255 }
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = wxSysErrorMsg(arg1);
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 {
12263 #if wxUSE_UNICODE
12264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12265 #else
12266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12267 #endif
12268 }
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj = 0;
12277 wxString *arg1 = 0 ;
12278 bool temp1 = false ;
12279 PyObject * obj0 = 0 ;
12280 char * kwnames[] = {
12281 (char *) "msg", NULL
12282 };
12283
12284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12285 {
12286 arg1 = wxString_in_helper(obj0);
12287 if (arg1 == NULL) SWIG_fail;
12288 temp1 = true;
12289 }
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 wxPyLogFatalError((wxString const &)*arg1);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_Py_Void();
12297 {
12298 if (temp1)
12299 delete arg1;
12300 }
12301 return resultobj;
12302 fail:
12303 {
12304 if (temp1)
12305 delete arg1;
12306 }
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 wxString *arg1 = 0 ;
12314 bool temp1 = false ;
12315 PyObject * obj0 = 0 ;
12316 char * kwnames[] = {
12317 (char *) "msg", NULL
12318 };
12319
12320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12321 {
12322 arg1 = wxString_in_helper(obj0);
12323 if (arg1 == NULL) SWIG_fail;
12324 temp1 = true;
12325 }
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 wxPyLogError((wxString const &)*arg1);
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 resultobj = SWIG_Py_Void();
12333 {
12334 if (temp1)
12335 delete arg1;
12336 }
12337 return resultobj;
12338 fail:
12339 {
12340 if (temp1)
12341 delete arg1;
12342 }
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj = 0;
12349 wxString *arg1 = 0 ;
12350 bool temp1 = false ;
12351 PyObject * obj0 = 0 ;
12352 char * kwnames[] = {
12353 (char *) "msg", NULL
12354 };
12355
12356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12357 {
12358 arg1 = wxString_in_helper(obj0);
12359 if (arg1 == NULL) SWIG_fail;
12360 temp1 = true;
12361 }
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 wxPyLogWarning((wxString const &)*arg1);
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 resultobj = SWIG_Py_Void();
12369 {
12370 if (temp1)
12371 delete arg1;
12372 }
12373 return resultobj;
12374 fail:
12375 {
12376 if (temp1)
12377 delete arg1;
12378 }
12379 return NULL;
12380 }
12381
12382
12383 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj = 0;
12385 wxString *arg1 = 0 ;
12386 bool temp1 = false ;
12387 PyObject * obj0 = 0 ;
12388 char * kwnames[] = {
12389 (char *) "msg", NULL
12390 };
12391
12392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12393 {
12394 arg1 = wxString_in_helper(obj0);
12395 if (arg1 == NULL) SWIG_fail;
12396 temp1 = true;
12397 }
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 wxPyLogMessage((wxString const &)*arg1);
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 resultobj = SWIG_Py_Void();
12405 {
12406 if (temp1)
12407 delete arg1;
12408 }
12409 return resultobj;
12410 fail:
12411 {
12412 if (temp1)
12413 delete arg1;
12414 }
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj = 0;
12421 wxString *arg1 = 0 ;
12422 bool temp1 = false ;
12423 PyObject * obj0 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "msg", NULL
12426 };
12427
12428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12429 {
12430 arg1 = wxString_in_helper(obj0);
12431 if (arg1 == NULL) SWIG_fail;
12432 temp1 = true;
12433 }
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 wxPyLogInfo((wxString const &)*arg1);
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 resultobj = SWIG_Py_Void();
12441 {
12442 if (temp1)
12443 delete arg1;
12444 }
12445 return resultobj;
12446 fail:
12447 {
12448 if (temp1)
12449 delete arg1;
12450 }
12451 return NULL;
12452 }
12453
12454
12455 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj = 0;
12457 wxString *arg1 = 0 ;
12458 bool temp1 = false ;
12459 PyObject * obj0 = 0 ;
12460 char * kwnames[] = {
12461 (char *) "msg", NULL
12462 };
12463
12464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12465 {
12466 arg1 = wxString_in_helper(obj0);
12467 if (arg1 == NULL) SWIG_fail;
12468 temp1 = true;
12469 }
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 wxPyLogDebug((wxString const &)*arg1);
12473 wxPyEndAllowThreads(__tstate);
12474 if (PyErr_Occurred()) SWIG_fail;
12475 }
12476 resultobj = SWIG_Py_Void();
12477 {
12478 if (temp1)
12479 delete arg1;
12480 }
12481 return resultobj;
12482 fail:
12483 {
12484 if (temp1)
12485 delete arg1;
12486 }
12487 return NULL;
12488 }
12489
12490
12491 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12492 PyObject *resultobj = 0;
12493 wxString *arg1 = 0 ;
12494 bool temp1 = false ;
12495 PyObject * obj0 = 0 ;
12496 char * kwnames[] = {
12497 (char *) "msg", NULL
12498 };
12499
12500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12501 {
12502 arg1 = wxString_in_helper(obj0);
12503 if (arg1 == NULL) SWIG_fail;
12504 temp1 = true;
12505 }
12506 {
12507 PyThreadState* __tstate = wxPyBeginAllowThreads();
12508 wxPyLogVerbose((wxString const &)*arg1);
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 resultobj = SWIG_Py_Void();
12513 {
12514 if (temp1)
12515 delete arg1;
12516 }
12517 return resultobj;
12518 fail:
12519 {
12520 if (temp1)
12521 delete arg1;
12522 }
12523 return NULL;
12524 }
12525
12526
12527 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12528 PyObject *resultobj = 0;
12529 wxString *arg1 = 0 ;
12530 bool temp1 = false ;
12531 PyObject * obj0 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "msg", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12537 {
12538 arg1 = wxString_in_helper(obj0);
12539 if (arg1 == NULL) SWIG_fail;
12540 temp1 = true;
12541 }
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxPyLogStatus((wxString const &)*arg1);
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 resultobj = SWIG_Py_Void();
12549 {
12550 if (temp1)
12551 delete arg1;
12552 }
12553 return resultobj;
12554 fail:
12555 {
12556 if (temp1)
12557 delete arg1;
12558 }
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 wxFrame *arg1 = (wxFrame *) 0 ;
12566 wxString *arg2 = 0 ;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 bool temp2 = false ;
12570 PyObject * obj0 = 0 ;
12571 PyObject * obj1 = 0 ;
12572 char * kwnames[] = {
12573 (char *) "pFrame",(char *) "msg", NULL
12574 };
12575
12576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12578 if (!SWIG_IsOK(res1)) {
12579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12580 }
12581 arg1 = reinterpret_cast< wxFrame * >(argp1);
12582 {
12583 arg2 = wxString_in_helper(obj1);
12584 if (arg2 == NULL) SWIG_fail;
12585 temp2 = true;
12586 }
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 resultobj = SWIG_Py_Void();
12594 {
12595 if (temp2)
12596 delete arg2;
12597 }
12598 return resultobj;
12599 fail:
12600 {
12601 if (temp2)
12602 delete arg2;
12603 }
12604 return NULL;
12605 }
12606
12607
12608 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12609 PyObject *resultobj = 0;
12610 wxString *arg1 = 0 ;
12611 bool temp1 = false ;
12612 PyObject * obj0 = 0 ;
12613 char * kwnames[] = {
12614 (char *) "msg", NULL
12615 };
12616
12617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12618 {
12619 arg1 = wxString_in_helper(obj0);
12620 if (arg1 == NULL) SWIG_fail;
12621 temp1 = true;
12622 }
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 wxPyLogSysError((wxString const &)*arg1);
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 resultobj = SWIG_Py_Void();
12630 {
12631 if (temp1)
12632 delete arg1;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (temp1)
12638 delete arg1;
12639 }
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 unsigned long arg1 ;
12647 wxString *arg2 = 0 ;
12648 unsigned long val1 ;
12649 int ecode1 = 0 ;
12650 bool temp2 = false ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 char * kwnames[] = {
12654 (char *) "level",(char *) "msg", NULL
12655 };
12656
12657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12658 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12659 if (!SWIG_IsOK(ecode1)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12661 }
12662 arg1 = static_cast< unsigned long >(val1);
12663 {
12664 arg2 = wxString_in_helper(obj1);
12665 if (arg2 == NULL) SWIG_fail;
12666 temp2 = true;
12667 }
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 resultobj = SWIG_Py_Void();
12675 {
12676 if (temp2)
12677 delete arg2;
12678 }
12679 return resultobj;
12680 fail:
12681 {
12682 if (temp2)
12683 delete arg2;
12684 }
12685 return NULL;
12686 }
12687
12688
12689 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12690 PyObject *resultobj = 0;
12691 unsigned long arg1 ;
12692 wxString *arg2 = 0 ;
12693 unsigned long val1 ;
12694 int ecode1 = 0 ;
12695 bool temp2 = false ;
12696
12697 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12698 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12699 if (!SWIG_IsOK(ecode1)) {
12700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12701 }
12702 arg1 = static_cast< unsigned long >(val1);
12703 {
12704 arg2 = wxString_in_helper(swig_obj[1]);
12705 if (arg2 == NULL) SWIG_fail;
12706 temp2 = true;
12707 }
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 wxPyLogTrace(arg1,(wxString const &)*arg2);
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 resultobj = SWIG_Py_Void();
12715 {
12716 if (temp2)
12717 delete arg2;
12718 }
12719 return resultobj;
12720 fail:
12721 {
12722 if (temp2)
12723 delete arg2;
12724 }
12725 return NULL;
12726 }
12727
12728
12729 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12730 PyObject *resultobj = 0;
12731 wxString *arg1 = 0 ;
12732 wxString *arg2 = 0 ;
12733 bool temp1 = false ;
12734 bool temp2 = false ;
12735
12736 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12737 {
12738 arg1 = wxString_in_helper(swig_obj[0]);
12739 if (arg1 == NULL) SWIG_fail;
12740 temp1 = true;
12741 }
12742 {
12743 arg2 = wxString_in_helper(swig_obj[1]);
12744 if (arg2 == NULL) SWIG_fail;
12745 temp2 = true;
12746 }
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 resultobj = SWIG_Py_Void();
12754 {
12755 if (temp1)
12756 delete arg1;
12757 }
12758 {
12759 if (temp2)
12760 delete arg2;
12761 }
12762 return resultobj;
12763 fail:
12764 {
12765 if (temp1)
12766 delete arg1;
12767 }
12768 {
12769 if (temp2)
12770 delete arg2;
12771 }
12772 return NULL;
12773 }
12774
12775
12776 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12777 int argc;
12778 PyObject *argv[3];
12779
12780 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12781 --argc;
12782 if (argc == 2) {
12783 int _v = 0;
12784 {
12785 {
12786 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12787 }
12788 }
12789 if (!_v) goto check_1;
12790 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12791 }
12792 check_1:
12793
12794 if (argc == 2) {
12795 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12796 }
12797
12798 fail:
12799 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12800 return NULL;
12801 }
12802
12803
12804 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12805 PyObject *resultobj = 0;
12806 wxString *arg1 = 0 ;
12807 wxString *arg2 = 0 ;
12808 bool temp1 = false ;
12809 bool temp2 = false ;
12810 PyObject * obj0 = 0 ;
12811 PyObject * obj1 = 0 ;
12812 char * kwnames[] = {
12813 (char *) "title",(char *) "text", NULL
12814 };
12815
12816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12817 {
12818 arg1 = wxString_in_helper(obj0);
12819 if (arg1 == NULL) SWIG_fail;
12820 temp1 = true;
12821 }
12822 {
12823 arg2 = wxString_in_helper(obj1);
12824 if (arg2 == NULL) SWIG_fail;
12825 temp2 = true;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 resultobj = SWIG_Py_Void();
12834 {
12835 if (temp1)
12836 delete arg1;
12837 }
12838 {
12839 if (temp2)
12840 delete arg2;
12841 }
12842 return resultobj;
12843 fail:
12844 {
12845 if (temp1)
12846 delete arg1;
12847 }
12848 {
12849 if (temp2)
12850 delete arg2;
12851 }
12852 return NULL;
12853 }
12854
12855
12856 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12857 PyObject *resultobj = 0;
12858 wxLogNull *result = 0 ;
12859
12860 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12861 {
12862 PyThreadState* __tstate = wxPyBeginAllowThreads();
12863 result = (wxLogNull *)new wxLogNull();
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12875 PyObject *resultobj = 0;
12876 wxLogNull *arg1 = (wxLogNull *) 0 ;
12877 void *argp1 = 0 ;
12878 int res1 = 0 ;
12879 PyObject *swig_obj[1] ;
12880
12881 if (!args) SWIG_fail;
12882 swig_obj[0] = args;
12883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12884 if (!SWIG_IsOK(res1)) {
12885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12886 }
12887 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 delete arg1;
12891
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 resultobj = SWIG_Py_Void();
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *obj;
12904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12905 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12906 return SWIG_Py_Void();
12907 }
12908
12909 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 return SWIG_Python_InitShadowInstance(args);
12911 }
12912
12913 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914 PyObject *resultobj = 0;
12915 wxPyLog *result = 0 ;
12916
12917 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 result = (wxPyLog *)new wxPyLog();
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj = 0;
12933 wxPyLog *arg1 = (wxPyLog *) 0 ;
12934 PyObject *arg2 = (PyObject *) 0 ;
12935 PyObject *arg3 = (PyObject *) 0 ;
12936 void *argp1 = 0 ;
12937 int res1 = 0 ;
12938 PyObject * obj0 = 0 ;
12939 PyObject * obj1 = 0 ;
12940 PyObject * obj2 = 0 ;
12941 char * kwnames[] = {
12942 (char *) "self",(char *) "self",(char *) "_class", NULL
12943 };
12944
12945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12947 if (!SWIG_IsOK(res1)) {
12948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12949 }
12950 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12951 arg2 = obj1;
12952 arg3 = obj2;
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 (arg1)->_setCallbackInfo(arg2,arg3);
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 resultobj = SWIG_Py_Void();
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 PyObject *obj;
12968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12969 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12970 return SWIG_Py_Void();
12971 }
12972
12973 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12974 return SWIG_Python_InitShadowInstance(args);
12975 }
12976
12977 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12978 PyObject *resultobj = 0;
12979 int arg1 ;
12980 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12981 int arg3 = (int) wxKILL_NOCHILDREN ;
12982 wxKillError result;
12983 int val1 ;
12984 int ecode1 = 0 ;
12985 int val2 ;
12986 int ecode2 = 0 ;
12987 int val3 ;
12988 int ecode3 = 0 ;
12989 PyObject * obj0 = 0 ;
12990 PyObject * obj1 = 0 ;
12991 PyObject * obj2 = 0 ;
12992 char * kwnames[] = {
12993 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12994 };
12995
12996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12997 ecode1 = SWIG_AsVal_int(obj0, &val1);
12998 if (!SWIG_IsOK(ecode1)) {
12999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13000 }
13001 arg1 = static_cast< int >(val1);
13002 if (obj1) {
13003 ecode2 = SWIG_AsVal_int(obj1, &val2);
13004 if (!SWIG_IsOK(ecode2)) {
13005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13006 }
13007 arg2 = static_cast< wxSignal >(val2);
13008 }
13009 if (obj2) {
13010 ecode3 = SWIG_AsVal_int(obj2, &val3);
13011 if (!SWIG_IsOK(ecode3)) {
13012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13013 }
13014 arg3 = static_cast< int >(val3);
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_From_int(static_cast< int >(result));
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13030 PyObject *resultobj = 0;
13031 int arg1 ;
13032 bool result;
13033 int val1 ;
13034 int ecode1 = 0 ;
13035 PyObject * obj0 = 0 ;
13036 char * kwnames[] = {
13037 (char *) "pid", NULL
13038 };
13039
13040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13041 ecode1 = SWIG_AsVal_int(obj0, &val1);
13042 if (!SWIG_IsOK(ecode1)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13044 }
13045 arg1 = static_cast< int >(val1);
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (bool)wxPyProcess::Exists(arg1);
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13054 }
13055 return resultobj;
13056 fail:
13057 return NULL;
13058 }
13059
13060
13061 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj = 0;
13063 wxString *arg1 = 0 ;
13064 int arg2 = (int) wxEXEC_ASYNC ;
13065 wxPyProcess *result = 0 ;
13066 bool temp1 = false ;
13067 int val2 ;
13068 int ecode2 = 0 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "cmd",(char *) "flags", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13076 {
13077 arg1 = wxString_in_helper(obj0);
13078 if (arg1 == NULL) SWIG_fail;
13079 temp1 = true;
13080 }
13081 if (obj1) {
13082 ecode2 = SWIG_AsVal_int(obj1, &val2);
13083 if (!SWIG_IsOK(ecode2)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13085 }
13086 arg2 = static_cast< int >(val2);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13095 {
13096 if (temp1)
13097 delete arg1;
13098 }
13099 return resultobj;
13100 fail:
13101 {
13102 if (temp1)
13103 delete arg1;
13104 }
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj = 0;
13111 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13112 int arg2 = (int) -1 ;
13113 wxPyProcess *result = 0 ;
13114 void *argp1 = 0 ;
13115 int res1 = 0 ;
13116 int val2 ;
13117 int ecode2 = 0 ;
13118 PyObject * obj0 = 0 ;
13119 PyObject * obj1 = 0 ;
13120 char * kwnames[] = {
13121 (char *) "parent",(char *) "id", NULL
13122 };
13123
13124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13125 if (obj0) {
13126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13127 if (!SWIG_IsOK(res1)) {
13128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13129 }
13130 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13131 }
13132 if (obj1) {
13133 ecode2 = SWIG_AsVal_int(obj1, &val2);
13134 if (!SWIG_IsOK(ecode2)) {
13135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13136 }
13137 arg2 = static_cast< int >(val2);
13138 }
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13153 PyObject *resultobj = 0;
13154 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13155 PyObject *arg2 = (PyObject *) 0 ;
13156 PyObject *arg3 = (PyObject *) 0 ;
13157 void *argp1 = 0 ;
13158 int res1 = 0 ;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 PyObject * obj2 = 0 ;
13162 char * kwnames[] = {
13163 (char *) "self",(char *) "self",(char *) "_class", NULL
13164 };
13165
13166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13168 if (!SWIG_IsOK(res1)) {
13169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13170 }
13171 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13172 arg2 = obj1;
13173 arg3 = obj2;
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 (arg1)->_setCallbackInfo(arg2,arg3);
13177 wxPyEndAllowThreads(__tstate);
13178 if (PyErr_Occurred()) SWIG_fail;
13179 }
13180 resultobj = SWIG_Py_Void();
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj = 0;
13189 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13190 int arg2 ;
13191 int arg3 ;
13192 void *argp1 = 0 ;
13193 int res1 = 0 ;
13194 int val2 ;
13195 int ecode2 = 0 ;
13196 int val3 ;
13197 int ecode3 = 0 ;
13198 PyObject * obj0 = 0 ;
13199 PyObject * obj1 = 0 ;
13200 PyObject * obj2 = 0 ;
13201 char * kwnames[] = {
13202 (char *) "self",(char *) "pid",(char *) "status", NULL
13203 };
13204
13205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13207 if (!SWIG_IsOK(res1)) {
13208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13209 }
13210 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13211 ecode2 = SWIG_AsVal_int(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13214 }
13215 arg2 = static_cast< int >(val2);
13216 ecode3 = SWIG_AsVal_int(obj2, &val3);
13217 if (!SWIG_IsOK(ecode3)) {
13218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13219 }
13220 arg3 = static_cast< int >(val3);
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 (arg1)->OnTerminate(arg2,arg3);
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 resultobj = SWIG_Py_Void();
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235 PyObject *resultobj = 0;
13236 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13237 void *argp1 = 0 ;
13238 int res1 = 0 ;
13239 PyObject *swig_obj[1] ;
13240
13241 if (!args) SWIG_fail;
13242 swig_obj[0] = args;
13243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13244 if (!SWIG_IsOK(res1)) {
13245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13246 }
13247 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 (arg1)->Redirect();
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_Py_Void();
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13262 PyObject *resultobj = 0;
13263 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13264 bool result;
13265 void *argp1 = 0 ;
13266 int res1 = 0 ;
13267 PyObject *swig_obj[1] ;
13268
13269 if (!args) SWIG_fail;
13270 swig_obj[0] = args;
13271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13274 }
13275 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13276 {
13277 PyThreadState* __tstate = wxPyBeginAllowThreads();
13278 result = (bool)(arg1)->IsRedirected();
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 {
13283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13284 }
13285 return resultobj;
13286 fail:
13287 return NULL;
13288 }
13289
13290
13291 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13292 PyObject *resultobj = 0;
13293 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13294 void *argp1 = 0 ;
13295 int res1 = 0 ;
13296 PyObject *swig_obj[1] ;
13297
13298 if (!args) SWIG_fail;
13299 swig_obj[0] = args;
13300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13303 }
13304 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 (arg1)->Detach();
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_Py_Void();
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13319 PyObject *resultobj = 0;
13320 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13321 wxInputStream *result = 0 ;
13322 void *argp1 = 0 ;
13323 int res1 = 0 ;
13324 PyObject *swig_obj[1] ;
13325
13326 if (!args) SWIG_fail;
13327 swig_obj[0] = args;
13328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13329 if (!SWIG_IsOK(res1)) {
13330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13331 }
13332 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 result = (wxInputStream *)(arg1)->GetInputStream();
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 {
13340 wxPyInputStream * _ptr = NULL;
13341
13342 if (result) {
13343 _ptr = new wxPyInputStream(result);
13344 }
13345 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13346 }
13347 return resultobj;
13348 fail:
13349 return NULL;
13350 }
13351
13352
13353 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13354 PyObject *resultobj = 0;
13355 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13356 wxInputStream *result = 0 ;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 PyObject *swig_obj[1] ;
13360
13361 if (!args) SWIG_fail;
13362 swig_obj[0] = args;
13363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13366 }
13367 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 result = (wxInputStream *)(arg1)->GetErrorStream();
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 {
13375 wxPyInputStream * _ptr = NULL;
13376
13377 if (result) {
13378 _ptr = new wxPyInputStream(result);
13379 }
13380 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13381 }
13382 return resultobj;
13383 fail:
13384 return NULL;
13385 }
13386
13387
13388 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13389 PyObject *resultobj = 0;
13390 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13391 wxOutputStream *result = 0 ;
13392 void *argp1 = 0 ;
13393 int res1 = 0 ;
13394 PyObject *swig_obj[1] ;
13395
13396 if (!args) SWIG_fail;
13397 swig_obj[0] = args;
13398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13399 if (!SWIG_IsOK(res1)) {
13400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13401 }
13402 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 result = (wxOutputStream *)(arg1)->GetOutputStream();
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13417 PyObject *resultobj = 0;
13418 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13419 void *argp1 = 0 ;
13420 int res1 = 0 ;
13421 PyObject *swig_obj[1] ;
13422
13423 if (!args) SWIG_fail;
13424 swig_obj[0] = args;
13425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13426 if (!SWIG_IsOK(res1)) {
13427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13428 }
13429 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 (arg1)->CloseOutput();
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = SWIG_Py_Void();
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13444 PyObject *resultobj = 0;
13445 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13446 bool result;
13447 void *argp1 = 0 ;
13448 int res1 = 0 ;
13449 PyObject *swig_obj[1] ;
13450
13451 if (!args) SWIG_fail;
13452 swig_obj[0] = args;
13453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13454 if (!SWIG_IsOK(res1)) {
13455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13456 }
13457 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13461 wxPyEndAllowThreads(__tstate);
13462 if (PyErr_Occurred()) SWIG_fail;
13463 }
13464 {
13465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13466 }
13467 return resultobj;
13468 fail:
13469 return NULL;
13470 }
13471
13472
13473 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13474 PyObject *resultobj = 0;
13475 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13476 bool result;
13477 void *argp1 = 0 ;
13478 int res1 = 0 ;
13479 PyObject *swig_obj[1] ;
13480
13481 if (!args) SWIG_fail;
13482 swig_obj[0] = args;
13483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13484 if (!SWIG_IsOK(res1)) {
13485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13486 }
13487 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 {
13495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13496 }
13497 return resultobj;
13498 fail:
13499 return NULL;
13500 }
13501
13502
13503 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13504 PyObject *resultobj = 0;
13505 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13506 bool result;
13507 void *argp1 = 0 ;
13508 int res1 = 0 ;
13509 PyObject *swig_obj[1] ;
13510
13511 if (!args) SWIG_fail;
13512 swig_obj[0] = args;
13513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13514 if (!SWIG_IsOK(res1)) {
13515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13516 }
13517 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 {
13525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13526 }
13527 return resultobj;
13528 fail:
13529 return NULL;
13530 }
13531
13532
13533 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13534 PyObject *obj;
13535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13536 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13537 return SWIG_Py_Void();
13538 }
13539
13540 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13541 return SWIG_Python_InitShadowInstance(args);
13542 }
13543
13544 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj = 0;
13546 int arg1 = (int) 0 ;
13547 int arg2 = (int) 0 ;
13548 int arg3 = (int) 0 ;
13549 wxProcessEvent *result = 0 ;
13550 int val1 ;
13551 int ecode1 = 0 ;
13552 int val2 ;
13553 int ecode2 = 0 ;
13554 int val3 ;
13555 int ecode3 = 0 ;
13556 PyObject * obj0 = 0 ;
13557 PyObject * obj1 = 0 ;
13558 PyObject * obj2 = 0 ;
13559 char * kwnames[] = {
13560 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13561 };
13562
13563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13564 if (obj0) {
13565 ecode1 = SWIG_AsVal_int(obj0, &val1);
13566 if (!SWIG_IsOK(ecode1)) {
13567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13568 }
13569 arg1 = static_cast< int >(val1);
13570 }
13571 if (obj1) {
13572 ecode2 = SWIG_AsVal_int(obj1, &val2);
13573 if (!SWIG_IsOK(ecode2)) {
13574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13575 }
13576 arg2 = static_cast< int >(val2);
13577 }
13578 if (obj2) {
13579 ecode3 = SWIG_AsVal_int(obj2, &val3);
13580 if (!SWIG_IsOK(ecode3)) {
13581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13582 }
13583 arg3 = static_cast< int >(val3);
13584 }
13585 {
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13588 wxPyEndAllowThreads(__tstate);
13589 if (PyErr_Occurred()) SWIG_fail;
13590 }
13591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13592 return resultobj;
13593 fail:
13594 return NULL;
13595 }
13596
13597
13598 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13599 PyObject *resultobj = 0;
13600 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13601 int result;
13602 void *argp1 = 0 ;
13603 int res1 = 0 ;
13604 PyObject *swig_obj[1] ;
13605
13606 if (!args) SWIG_fail;
13607 swig_obj[0] = args;
13608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13609 if (!SWIG_IsOK(res1)) {
13610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13611 }
13612 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13613 {
13614 PyThreadState* __tstate = wxPyBeginAllowThreads();
13615 result = (int)(arg1)->GetPid();
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 resultobj = SWIG_From_int(static_cast< int >(result));
13620 return resultobj;
13621 fail:
13622 return NULL;
13623 }
13624
13625
13626 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13627 PyObject *resultobj = 0;
13628 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13629 int result;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 PyObject *swig_obj[1] ;
13633
13634 if (!args) SWIG_fail;
13635 swig_obj[0] = args;
13636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13637 if (!SWIG_IsOK(res1)) {
13638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13639 }
13640 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13641 {
13642 PyThreadState* __tstate = wxPyBeginAllowThreads();
13643 result = (int)(arg1)->GetExitCode();
13644 wxPyEndAllowThreads(__tstate);
13645 if (PyErr_Occurred()) SWIG_fail;
13646 }
13647 resultobj = SWIG_From_int(static_cast< int >(result));
13648 return resultobj;
13649 fail:
13650 return NULL;
13651 }
13652
13653
13654 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13655 PyObject *resultobj = 0;
13656 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13657 int arg2 ;
13658 void *argp1 = 0 ;
13659 int res1 = 0 ;
13660 int val2 ;
13661 int ecode2 = 0 ;
13662 PyObject *swig_obj[2] ;
13663
13664 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13666 if (!SWIG_IsOK(res1)) {
13667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13668 }
13669 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13670 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13671 if (!SWIG_IsOK(ecode2)) {
13672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13673 }
13674 arg2 = static_cast< int >(val2);
13675 if (arg1) (arg1)->m_pid = arg2;
13676
13677 resultobj = SWIG_Py_Void();
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13685 PyObject *resultobj = 0;
13686 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13687 int result;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 PyObject *swig_obj[1] ;
13691
13692 if (!args) SWIG_fail;
13693 swig_obj[0] = args;
13694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13695 if (!SWIG_IsOK(res1)) {
13696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13697 }
13698 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13699 result = (int) ((arg1)->m_pid);
13700 resultobj = SWIG_From_int(static_cast< int >(result));
13701 return resultobj;
13702 fail:
13703 return NULL;
13704 }
13705
13706
13707 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13708 PyObject *resultobj = 0;
13709 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13710 int arg2 ;
13711 void *argp1 = 0 ;
13712 int res1 = 0 ;
13713 int val2 ;
13714 int ecode2 = 0 ;
13715 PyObject *swig_obj[2] ;
13716
13717 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13719 if (!SWIG_IsOK(res1)) {
13720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13721 }
13722 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13723 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13724 if (!SWIG_IsOK(ecode2)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13726 }
13727 arg2 = static_cast< int >(val2);
13728 if (arg1) (arg1)->m_exitcode = arg2;
13729
13730 resultobj = SWIG_Py_Void();
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13738 PyObject *resultobj = 0;
13739 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13740 int result;
13741 void *argp1 = 0 ;
13742 int res1 = 0 ;
13743 PyObject *swig_obj[1] ;
13744
13745 if (!args) SWIG_fail;
13746 swig_obj[0] = args;
13747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13748 if (!SWIG_IsOK(res1)) {
13749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13750 }
13751 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13752 result = (int) ((arg1)->m_exitcode);
13753 resultobj = SWIG_From_int(static_cast< int >(result));
13754 return resultobj;
13755 fail:
13756 return NULL;
13757 }
13758
13759
13760 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13761 PyObject *obj;
13762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13763 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13764 return SWIG_Py_Void();
13765 }
13766
13767 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13768 return SWIG_Python_InitShadowInstance(args);
13769 }
13770
13771 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj = 0;
13773 wxString *arg1 = 0 ;
13774 int arg2 = (int) wxEXEC_ASYNC ;
13775 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13776 long result;
13777 bool temp1 = false ;
13778 int val2 ;
13779 int ecode2 = 0 ;
13780 void *argp3 = 0 ;
13781 int res3 = 0 ;
13782 PyObject * obj0 = 0 ;
13783 PyObject * obj1 = 0 ;
13784 PyObject * obj2 = 0 ;
13785 char * kwnames[] = {
13786 (char *) "command",(char *) "flags",(char *) "process", NULL
13787 };
13788
13789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13790 {
13791 arg1 = wxString_in_helper(obj0);
13792 if (arg1 == NULL) SWIG_fail;
13793 temp1 = true;
13794 }
13795 if (obj1) {
13796 ecode2 = SWIG_AsVal_int(obj1, &val2);
13797 if (!SWIG_IsOK(ecode2)) {
13798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13799 }
13800 arg2 = static_cast< int >(val2);
13801 }
13802 if (obj2) {
13803 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13804 if (!SWIG_IsOK(res3)) {
13805 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13806 }
13807 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13808 }
13809 {
13810 if (!wxPyCheckForApp()) SWIG_fail;
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_From_long(static_cast< long >(result));
13817 {
13818 if (temp1)
13819 delete arg1;
13820 }
13821 return resultobj;
13822 fail:
13823 {
13824 if (temp1)
13825 delete arg1;
13826 }
13827 return NULL;
13828 }
13829
13830
13831 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13832 PyObject *resultobj = 0;
13833 long arg1 ;
13834 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13835 wxKillError *arg3 = (wxKillError *) 0 ;
13836 int arg4 = (int) wxKILL_NOCHILDREN ;
13837 int result;
13838 long val1 ;
13839 int ecode1 = 0 ;
13840 int val2 ;
13841 int ecode2 = 0 ;
13842 wxKillError temp3 ;
13843 int val4 ;
13844 int ecode4 = 0 ;
13845 PyObject * obj0 = 0 ;
13846 PyObject * obj1 = 0 ;
13847 PyObject * obj2 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13850 };
13851
13852 {
13853 arg3 = &temp3;
13854 }
13855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13856 ecode1 = SWIG_AsVal_long(obj0, &val1);
13857 if (!SWIG_IsOK(ecode1)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13859 }
13860 arg1 = static_cast< long >(val1);
13861 if (obj1) {
13862 ecode2 = SWIG_AsVal_int(obj1, &val2);
13863 if (!SWIG_IsOK(ecode2)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13865 }
13866 arg2 = static_cast< wxSignal >(val2);
13867 }
13868 if (obj2) {
13869 ecode4 = SWIG_AsVal_int(obj2, &val4);
13870 if (!SWIG_IsOK(ecode4)) {
13871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13872 }
13873 arg4 = static_cast< int >(val4);
13874 }
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (int)wxKill(arg1,arg2,arg3,arg4);
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 resultobj = SWIG_From_int(static_cast< int >(result));
13882 {
13883 PyObject* o;
13884 o = PyInt_FromLong((long) (*arg3));
13885
13886
13887
13888 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13889
13890 }
13891 return resultobj;
13892 fail:
13893 return NULL;
13894 }
13895
13896
13897 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13898 PyObject *resultobj = 0;
13899 int arg1 = (int) wxJOYSTICK1 ;
13900 wxJoystick *result = 0 ;
13901 int val1 ;
13902 int ecode1 = 0 ;
13903 PyObject * obj0 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "joystick", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13909 if (obj0) {
13910 ecode1 = SWIG_AsVal_int(obj0, &val1);
13911 if (!SWIG_IsOK(ecode1)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13913 }
13914 arg1 = static_cast< int >(val1);
13915 }
13916 {
13917 if (!wxPyCheckForApp()) SWIG_fail;
13918 PyThreadState* __tstate = wxPyBeginAllowThreads();
13919 result = (wxJoystick *)new wxJoystick(arg1);
13920 wxPyEndAllowThreads(__tstate);
13921 if (PyErr_Occurred()) SWIG_fail;
13922 }
13923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13931 PyObject *resultobj = 0;
13932 wxJoystick *arg1 = (wxJoystick *) 0 ;
13933 void *argp1 = 0 ;
13934 int res1 = 0 ;
13935 PyObject *swig_obj[1] ;
13936
13937 if (!args) SWIG_fail;
13938 swig_obj[0] = args;
13939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13940 if (!SWIG_IsOK(res1)) {
13941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13942 }
13943 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 delete arg1;
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_Py_Void();
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13959 PyObject *resultobj = 0;
13960 wxJoystick *arg1 = (wxJoystick *) 0 ;
13961 wxPoint result;
13962 void *argp1 = 0 ;
13963 int res1 = 0 ;
13964 PyObject *swig_obj[1] ;
13965
13966 if (!args) SWIG_fail;
13967 swig_obj[0] = args;
13968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13969 if (!SWIG_IsOK(res1)) {
13970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13971 }
13972 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (arg1)->GetPosition();
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13987 PyObject *resultobj = 0;
13988 wxJoystick *arg1 = (wxJoystick *) 0 ;
13989 int result;
13990 void *argp1 = 0 ;
13991 int res1 = 0 ;
13992 PyObject *swig_obj[1] ;
13993
13994 if (!args) SWIG_fail;
13995 swig_obj[0] = args;
13996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13999 }
14000 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 result = (int)(arg1)->GetZPosition();
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 resultobj = SWIG_From_int(static_cast< int >(result));
14008 return resultobj;
14009 fail:
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14015 PyObject *resultobj = 0;
14016 wxJoystick *arg1 = (wxJoystick *) 0 ;
14017 int result;
14018 void *argp1 = 0 ;
14019 int res1 = 0 ;
14020 PyObject *swig_obj[1] ;
14021
14022 if (!args) SWIG_fail;
14023 swig_obj[0] = args;
14024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14025 if (!SWIG_IsOK(res1)) {
14026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14027 }
14028 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14029 {
14030 PyThreadState* __tstate = wxPyBeginAllowThreads();
14031 result = (int)(arg1)->GetButtonState();
14032 wxPyEndAllowThreads(__tstate);
14033 if (PyErr_Occurred()) SWIG_fail;
14034 }
14035 resultobj = SWIG_From_int(static_cast< int >(result));
14036 return resultobj;
14037 fail:
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14043 PyObject *resultobj = 0;
14044 wxJoystick *arg1 = (wxJoystick *) 0 ;
14045 int result;
14046 void *argp1 = 0 ;
14047 int res1 = 0 ;
14048 PyObject *swig_obj[1] ;
14049
14050 if (!args) SWIG_fail;
14051 swig_obj[0] = args;
14052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14053 if (!SWIG_IsOK(res1)) {
14054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14055 }
14056 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 result = (int)(arg1)->GetPOVPosition();
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_From_int(static_cast< int >(result));
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14071 PyObject *resultobj = 0;
14072 wxJoystick *arg1 = (wxJoystick *) 0 ;
14073 int result;
14074 void *argp1 = 0 ;
14075 int res1 = 0 ;
14076 PyObject *swig_obj[1] ;
14077
14078 if (!args) SWIG_fail;
14079 swig_obj[0] = args;
14080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14083 }
14084 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 result = (int)(arg1)->GetPOVCTSPosition();
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_From_int(static_cast< int >(result));
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14099 PyObject *resultobj = 0;
14100 wxJoystick *arg1 = (wxJoystick *) 0 ;
14101 int result;
14102 void *argp1 = 0 ;
14103 int res1 = 0 ;
14104 PyObject *swig_obj[1] ;
14105
14106 if (!args) SWIG_fail;
14107 swig_obj[0] = args;
14108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14111 }
14112 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 result = (int)(arg1)->GetRudderPosition();
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 resultobj = SWIG_From_int(static_cast< int >(result));
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14127 PyObject *resultobj = 0;
14128 wxJoystick *arg1 = (wxJoystick *) 0 ;
14129 int result;
14130 void *argp1 = 0 ;
14131 int res1 = 0 ;
14132 PyObject *swig_obj[1] ;
14133
14134 if (!args) SWIG_fail;
14135 swig_obj[0] = args;
14136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14137 if (!SWIG_IsOK(res1)) {
14138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14139 }
14140 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 result = (int)(arg1)->GetUPosition();
14144 wxPyEndAllowThreads(__tstate);
14145 if (PyErr_Occurred()) SWIG_fail;
14146 }
14147 resultobj = SWIG_From_int(static_cast< int >(result));
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14155 PyObject *resultobj = 0;
14156 wxJoystick *arg1 = (wxJoystick *) 0 ;
14157 int result;
14158 void *argp1 = 0 ;
14159 int res1 = 0 ;
14160 PyObject *swig_obj[1] ;
14161
14162 if (!args) SWIG_fail;
14163 swig_obj[0] = args;
14164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14167 }
14168 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 result = (int)(arg1)->GetVPosition();
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 resultobj = SWIG_From_int(static_cast< int >(result));
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *resultobj = 0;
14184 wxJoystick *arg1 = (wxJoystick *) 0 ;
14185 int result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 PyObject *swig_obj[1] ;
14189
14190 if (!args) SWIG_fail;
14191 swig_obj[0] = args;
14192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14193 if (!SWIG_IsOK(res1)) {
14194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14195 }
14196 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (int)(arg1)->GetMovementThreshold();
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 resultobj = SWIG_From_int(static_cast< int >(result));
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14211 PyObject *resultobj = 0;
14212 wxJoystick *arg1 = (wxJoystick *) 0 ;
14213 int arg2 ;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 int val2 ;
14217 int ecode2 = 0 ;
14218 PyObject * obj0 = 0 ;
14219 PyObject * obj1 = 0 ;
14220 char * kwnames[] = {
14221 (char *) "self",(char *) "threshold", NULL
14222 };
14223
14224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14226 if (!SWIG_IsOK(res1)) {
14227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14228 }
14229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14230 ecode2 = SWIG_AsVal_int(obj1, &val2);
14231 if (!SWIG_IsOK(ecode2)) {
14232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14233 }
14234 arg2 = static_cast< int >(val2);
14235 {
14236 PyThreadState* __tstate = wxPyBeginAllowThreads();
14237 (arg1)->SetMovementThreshold(arg2);
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 resultobj = SWIG_Py_Void();
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14249 PyObject *resultobj = 0;
14250 wxJoystick *arg1 = (wxJoystick *) 0 ;
14251 bool result;
14252 void *argp1 = 0 ;
14253 int res1 = 0 ;
14254 PyObject *swig_obj[1] ;
14255
14256 if (!args) SWIG_fail;
14257 swig_obj[0] = args;
14258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14261 }
14262 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 result = (bool)(arg1)->IsOk();
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 {
14270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14279 PyObject *resultobj = 0;
14280 wxJoystick *arg1 = (wxJoystick *) 0 ;
14281 int result;
14282 void *argp1 = 0 ;
14283 int res1 = 0 ;
14284 PyObject *swig_obj[1] ;
14285
14286 if (!args) SWIG_fail;
14287 swig_obj[0] = args;
14288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14289 if (!SWIG_IsOK(res1)) {
14290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14291 }
14292 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 result = (int)(arg1)->GetNumberJoysticks();
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = SWIG_From_int(static_cast< int >(result));
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14307 PyObject *resultobj = 0;
14308 wxJoystick *arg1 = (wxJoystick *) 0 ;
14309 int result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 PyObject *swig_obj[1] ;
14313
14314 if (!args) SWIG_fail;
14315 swig_obj[0] = args;
14316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14317 if (!SWIG_IsOK(res1)) {
14318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14319 }
14320 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 result = (int)(arg1)->GetManufacturerId();
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 resultobj = SWIG_From_int(static_cast< int >(result));
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14335 PyObject *resultobj = 0;
14336 wxJoystick *arg1 = (wxJoystick *) 0 ;
14337 int result;
14338 void *argp1 = 0 ;
14339 int res1 = 0 ;
14340 PyObject *swig_obj[1] ;
14341
14342 if (!args) SWIG_fail;
14343 swig_obj[0] = args;
14344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14345 if (!SWIG_IsOK(res1)) {
14346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14347 }
14348 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (int)(arg1)->GetProductId();
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 resultobj = SWIG_From_int(static_cast< int >(result));
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14363 PyObject *resultobj = 0;
14364 wxJoystick *arg1 = (wxJoystick *) 0 ;
14365 wxString result;
14366 void *argp1 = 0 ;
14367 int res1 = 0 ;
14368 PyObject *swig_obj[1] ;
14369
14370 if (!args) SWIG_fail;
14371 swig_obj[0] = args;
14372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14373 if (!SWIG_IsOK(res1)) {
14374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14375 }
14376 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (arg1)->GetProductName();
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 #if wxUSE_UNICODE
14385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14386 #else
14387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14388 #endif
14389 }
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14397 PyObject *resultobj = 0;
14398 wxJoystick *arg1 = (wxJoystick *) 0 ;
14399 int result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 PyObject *swig_obj[1] ;
14403
14404 if (!args) SWIG_fail;
14405 swig_obj[0] = args;
14406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14407 if (!SWIG_IsOK(res1)) {
14408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14409 }
14410 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (int)(arg1)->GetXMin();
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = SWIG_From_int(static_cast< int >(result));
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14425 PyObject *resultobj = 0;
14426 wxJoystick *arg1 = (wxJoystick *) 0 ;
14427 int result;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 PyObject *swig_obj[1] ;
14431
14432 if (!args) SWIG_fail;
14433 swig_obj[0] = args;
14434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14437 }
14438 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (int)(arg1)->GetYMin();
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 resultobj = SWIG_From_int(static_cast< int >(result));
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14453 PyObject *resultobj = 0;
14454 wxJoystick *arg1 = (wxJoystick *) 0 ;
14455 int result;
14456 void *argp1 = 0 ;
14457 int res1 = 0 ;
14458 PyObject *swig_obj[1] ;
14459
14460 if (!args) SWIG_fail;
14461 swig_obj[0] = args;
14462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14463 if (!SWIG_IsOK(res1)) {
14464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14465 }
14466 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (int)(arg1)->GetZMin();
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = SWIG_From_int(static_cast< int >(result));
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14481 PyObject *resultobj = 0;
14482 wxJoystick *arg1 = (wxJoystick *) 0 ;
14483 int result;
14484 void *argp1 = 0 ;
14485 int res1 = 0 ;
14486 PyObject *swig_obj[1] ;
14487
14488 if (!args) SWIG_fail;
14489 swig_obj[0] = args;
14490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14493 }
14494 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (int)(arg1)->GetXMax();
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 resultobj = SWIG_From_int(static_cast< int >(result));
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14509 PyObject *resultobj = 0;
14510 wxJoystick *arg1 = (wxJoystick *) 0 ;
14511 int result;
14512 void *argp1 = 0 ;
14513 int res1 = 0 ;
14514 PyObject *swig_obj[1] ;
14515
14516 if (!args) SWIG_fail;
14517 swig_obj[0] = args;
14518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14521 }
14522 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14523 {
14524 PyThreadState* __tstate = wxPyBeginAllowThreads();
14525 result = (int)(arg1)->GetYMax();
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 resultobj = SWIG_From_int(static_cast< int >(result));
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14537 PyObject *resultobj = 0;
14538 wxJoystick *arg1 = (wxJoystick *) 0 ;
14539 int result;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 PyObject *swig_obj[1] ;
14543
14544 if (!args) SWIG_fail;
14545 swig_obj[0] = args;
14546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14547 if (!SWIG_IsOK(res1)) {
14548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14549 }
14550 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (int)(arg1)->GetZMax();
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 resultobj = SWIG_From_int(static_cast< int >(result));
14558 return resultobj;
14559 fail:
14560 return NULL;
14561 }
14562
14563
14564 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14565 PyObject *resultobj = 0;
14566 wxJoystick *arg1 = (wxJoystick *) 0 ;
14567 int result;
14568 void *argp1 = 0 ;
14569 int res1 = 0 ;
14570 PyObject *swig_obj[1] ;
14571
14572 if (!args) SWIG_fail;
14573 swig_obj[0] = args;
14574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14575 if (!SWIG_IsOK(res1)) {
14576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14577 }
14578 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = (int)(arg1)->GetNumberButtons();
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 resultobj = SWIG_From_int(static_cast< int >(result));
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14593 PyObject *resultobj = 0;
14594 wxJoystick *arg1 = (wxJoystick *) 0 ;
14595 int result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 PyObject *swig_obj[1] ;
14599
14600 if (!args) SWIG_fail;
14601 swig_obj[0] = args;
14602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14605 }
14606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (int)(arg1)->GetNumberAxes();
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_From_int(static_cast< int >(result));
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14621 PyObject *resultobj = 0;
14622 wxJoystick *arg1 = (wxJoystick *) 0 ;
14623 int result;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 PyObject *swig_obj[1] ;
14627
14628 if (!args) SWIG_fail;
14629 swig_obj[0] = args;
14630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14631 if (!SWIG_IsOK(res1)) {
14632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14633 }
14634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 result = (int)(arg1)->GetMaxButtons();
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 resultobj = SWIG_From_int(static_cast< int >(result));
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14649 PyObject *resultobj = 0;
14650 wxJoystick *arg1 = (wxJoystick *) 0 ;
14651 int result;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 PyObject *swig_obj[1] ;
14655
14656 if (!args) SWIG_fail;
14657 swig_obj[0] = args;
14658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14659 if (!SWIG_IsOK(res1)) {
14660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14661 }
14662 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (int)(arg1)->GetMaxAxes();
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 resultobj = SWIG_From_int(static_cast< int >(result));
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14677 PyObject *resultobj = 0;
14678 wxJoystick *arg1 = (wxJoystick *) 0 ;
14679 int result;
14680 void *argp1 = 0 ;
14681 int res1 = 0 ;
14682 PyObject *swig_obj[1] ;
14683
14684 if (!args) SWIG_fail;
14685 swig_obj[0] = args;
14686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14687 if (!SWIG_IsOK(res1)) {
14688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14689 }
14690 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (int)(arg1)->GetPollingMin();
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 resultobj = SWIG_From_int(static_cast< int >(result));
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705 PyObject *resultobj = 0;
14706 wxJoystick *arg1 = (wxJoystick *) 0 ;
14707 int result;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 PyObject *swig_obj[1] ;
14711
14712 if (!args) SWIG_fail;
14713 swig_obj[0] = args;
14714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14715 if (!SWIG_IsOK(res1)) {
14716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14717 }
14718 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (int)(arg1)->GetPollingMax();
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_From_int(static_cast< int >(result));
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxJoystick *arg1 = (wxJoystick *) 0 ;
14735 int result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14745 }
14746 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (int)(arg1)->GetRudderMin();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_From_int(static_cast< int >(result));
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14761 PyObject *resultobj = 0;
14762 wxJoystick *arg1 = (wxJoystick *) 0 ;
14763 int result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject *swig_obj[1] ;
14767
14768 if (!args) SWIG_fail;
14769 swig_obj[0] = args;
14770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14771 if (!SWIG_IsOK(res1)) {
14772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14773 }
14774 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (int)(arg1)->GetRudderMax();
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_From_int(static_cast< int >(result));
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxJoystick *arg1 = (wxJoystick *) 0 ;
14791 int result;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 PyObject *swig_obj[1] ;
14795
14796 if (!args) SWIG_fail;
14797 swig_obj[0] = args;
14798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14799 if (!SWIG_IsOK(res1)) {
14800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14801 }
14802 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (int)(arg1)->GetUMin();
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 resultobj = SWIG_From_int(static_cast< int >(result));
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14817 PyObject *resultobj = 0;
14818 wxJoystick *arg1 = (wxJoystick *) 0 ;
14819 int result;
14820 void *argp1 = 0 ;
14821 int res1 = 0 ;
14822 PyObject *swig_obj[1] ;
14823
14824 if (!args) SWIG_fail;
14825 swig_obj[0] = args;
14826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14829 }
14830 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (int)(arg1)->GetUMax();
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 resultobj = SWIG_From_int(static_cast< int >(result));
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14845 PyObject *resultobj = 0;
14846 wxJoystick *arg1 = (wxJoystick *) 0 ;
14847 int result;
14848 void *argp1 = 0 ;
14849 int res1 = 0 ;
14850 PyObject *swig_obj[1] ;
14851
14852 if (!args) SWIG_fail;
14853 swig_obj[0] = args;
14854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14855 if (!SWIG_IsOK(res1)) {
14856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14857 }
14858 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (int)(arg1)->GetVMin();
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 resultobj = SWIG_From_int(static_cast< int >(result));
14866 return resultobj;
14867 fail:
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14873 PyObject *resultobj = 0;
14874 wxJoystick *arg1 = (wxJoystick *) 0 ;
14875 int result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 PyObject *swig_obj[1] ;
14879
14880 if (!args) SWIG_fail;
14881 swig_obj[0] = args;
14882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14883 if (!SWIG_IsOK(res1)) {
14884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14885 }
14886 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = (int)(arg1)->GetVMax();
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 resultobj = SWIG_From_int(static_cast< int >(result));
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14901 PyObject *resultobj = 0;
14902 wxJoystick *arg1 = (wxJoystick *) 0 ;
14903 bool result;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 PyObject *swig_obj[1] ;
14907
14908 if (!args) SWIG_fail;
14909 swig_obj[0] = args;
14910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14913 }
14914 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (bool)(arg1)->HasRudder();
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14923 }
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14931 PyObject *resultobj = 0;
14932 wxJoystick *arg1 = (wxJoystick *) 0 ;
14933 bool result;
14934 void *argp1 = 0 ;
14935 int res1 = 0 ;
14936 PyObject *swig_obj[1] ;
14937
14938 if (!args) SWIG_fail;
14939 swig_obj[0] = args;
14940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14941 if (!SWIG_IsOK(res1)) {
14942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14943 }
14944 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (bool)(arg1)->HasZ();
14948 wxPyEndAllowThreads(__tstate);
14949 if (PyErr_Occurred()) SWIG_fail;
14950 }
14951 {
14952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14953 }
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14961 PyObject *resultobj = 0;
14962 wxJoystick *arg1 = (wxJoystick *) 0 ;
14963 bool result;
14964 void *argp1 = 0 ;
14965 int res1 = 0 ;
14966 PyObject *swig_obj[1] ;
14967
14968 if (!args) SWIG_fail;
14969 swig_obj[0] = args;
14970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14971 if (!SWIG_IsOK(res1)) {
14972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14973 }
14974 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (bool)(arg1)->HasU();
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 {
14982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14983 }
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14991 PyObject *resultobj = 0;
14992 wxJoystick *arg1 = (wxJoystick *) 0 ;
14993 bool result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 PyObject *swig_obj[1] ;
14997
14998 if (!args) SWIG_fail;
14999 swig_obj[0] = args;
15000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15001 if (!SWIG_IsOK(res1)) {
15002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15003 }
15004 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15005 {
15006 PyThreadState* __tstate = wxPyBeginAllowThreads();
15007 result = (bool)(arg1)->HasV();
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 {
15012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15013 }
15014 return resultobj;
15015 fail:
15016 return NULL;
15017 }
15018
15019
15020 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15021 PyObject *resultobj = 0;
15022 wxJoystick *arg1 = (wxJoystick *) 0 ;
15023 bool result;
15024 void *argp1 = 0 ;
15025 int res1 = 0 ;
15026 PyObject *swig_obj[1] ;
15027
15028 if (!args) SWIG_fail;
15029 swig_obj[0] = args;
15030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15031 if (!SWIG_IsOK(res1)) {
15032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15033 }
15034 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15035 {
15036 PyThreadState* __tstate = wxPyBeginAllowThreads();
15037 result = (bool)(arg1)->HasPOV();
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 {
15042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15043 }
15044 return resultobj;
15045 fail:
15046 return NULL;
15047 }
15048
15049
15050 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15051 PyObject *resultobj = 0;
15052 wxJoystick *arg1 = (wxJoystick *) 0 ;
15053 bool result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 PyObject *swig_obj[1] ;
15057
15058 if (!args) SWIG_fail;
15059 swig_obj[0] = args;
15060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15063 }
15064 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (bool)(arg1)->HasPOV4Dir();
15068 wxPyEndAllowThreads(__tstate);
15069 if (PyErr_Occurred()) SWIG_fail;
15070 }
15071 {
15072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15073 }
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15081 PyObject *resultobj = 0;
15082 wxJoystick *arg1 = (wxJoystick *) 0 ;
15083 bool result;
15084 void *argp1 = 0 ;
15085 int res1 = 0 ;
15086 PyObject *swig_obj[1] ;
15087
15088 if (!args) SWIG_fail;
15089 swig_obj[0] = args;
15090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15091 if (!SWIG_IsOK(res1)) {
15092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15093 }
15094 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (bool)(arg1)->HasPOVCTS();
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 {
15102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15103 }
15104 return resultobj;
15105 fail:
15106 return NULL;
15107 }
15108
15109
15110 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15111 PyObject *resultobj = 0;
15112 wxJoystick *arg1 = (wxJoystick *) 0 ;
15113 wxWindow *arg2 = (wxWindow *) 0 ;
15114 int arg3 = (int) 0 ;
15115 bool result;
15116 void *argp1 = 0 ;
15117 int res1 = 0 ;
15118 void *argp2 = 0 ;
15119 int res2 = 0 ;
15120 int val3 ;
15121 int ecode3 = 0 ;
15122 PyObject * obj0 = 0 ;
15123 PyObject * obj1 = 0 ;
15124 PyObject * obj2 = 0 ;
15125 char * kwnames[] = {
15126 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15127 };
15128
15129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15131 if (!SWIG_IsOK(res1)) {
15132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15133 }
15134 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15136 if (!SWIG_IsOK(res2)) {
15137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15138 }
15139 arg2 = reinterpret_cast< wxWindow * >(argp2);
15140 if (obj2) {
15141 ecode3 = SWIG_AsVal_int(obj2, &val3);
15142 if (!SWIG_IsOK(ecode3)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15144 }
15145 arg3 = static_cast< int >(val3);
15146 }
15147 {
15148 PyThreadState* __tstate = wxPyBeginAllowThreads();
15149 result = (bool)(arg1)->SetCapture(arg2,arg3);
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 {
15154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15155 }
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15163 PyObject *resultobj = 0;
15164 wxJoystick *arg1 = (wxJoystick *) 0 ;
15165 bool result;
15166 void *argp1 = 0 ;
15167 int res1 = 0 ;
15168 PyObject *swig_obj[1] ;
15169
15170 if (!args) SWIG_fail;
15171 swig_obj[0] = args;
15172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15173 if (!SWIG_IsOK(res1)) {
15174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15175 }
15176 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15177 {
15178 PyThreadState* __tstate = wxPyBeginAllowThreads();
15179 result = (bool)(arg1)->ReleaseCapture();
15180 wxPyEndAllowThreads(__tstate);
15181 if (PyErr_Occurred()) SWIG_fail;
15182 }
15183 {
15184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15185 }
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *obj;
15194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15195 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15196 return SWIG_Py_Void();
15197 }
15198
15199 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15200 return SWIG_Python_InitShadowInstance(args);
15201 }
15202
15203 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj = 0;
15205 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15206 int arg2 = (int) 0 ;
15207 int arg3 = (int) wxJOYSTICK1 ;
15208 int arg4 = (int) 0 ;
15209 wxJoystickEvent *result = 0 ;
15210 int val1 ;
15211 int ecode1 = 0 ;
15212 int val2 ;
15213 int ecode2 = 0 ;
15214 int val3 ;
15215 int ecode3 = 0 ;
15216 int val4 ;
15217 int ecode4 = 0 ;
15218 PyObject * obj0 = 0 ;
15219 PyObject * obj1 = 0 ;
15220 PyObject * obj2 = 0 ;
15221 PyObject * obj3 = 0 ;
15222 char * kwnames[] = {
15223 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15224 };
15225
15226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15227 if (obj0) {
15228 ecode1 = SWIG_AsVal_int(obj0, &val1);
15229 if (!SWIG_IsOK(ecode1)) {
15230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15231 }
15232 arg1 = static_cast< wxEventType >(val1);
15233 }
15234 if (obj1) {
15235 ecode2 = SWIG_AsVal_int(obj1, &val2);
15236 if (!SWIG_IsOK(ecode2)) {
15237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15238 }
15239 arg2 = static_cast< int >(val2);
15240 }
15241 if (obj2) {
15242 ecode3 = SWIG_AsVal_int(obj2, &val3);
15243 if (!SWIG_IsOK(ecode3)) {
15244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15245 }
15246 arg3 = static_cast< int >(val3);
15247 }
15248 if (obj3) {
15249 ecode4 = SWIG_AsVal_int(obj3, &val4);
15250 if (!SWIG_IsOK(ecode4)) {
15251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15252 }
15253 arg4 = static_cast< int >(val4);
15254 }
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15269 PyObject *resultobj = 0;
15270 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15271 wxPoint result;
15272 void *argp1 = 0 ;
15273 int res1 = 0 ;
15274 PyObject *swig_obj[1] ;
15275
15276 if (!args) SWIG_fail;
15277 swig_obj[0] = args;
15278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15279 if (!SWIG_IsOK(res1)) {
15280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15281 }
15282 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15297 PyObject *resultobj = 0;
15298 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15299 int result;
15300 void *argp1 = 0 ;
15301 int res1 = 0 ;
15302 PyObject *swig_obj[1] ;
15303
15304 if (!args) SWIG_fail;
15305 swig_obj[0] = args;
15306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15307 if (!SWIG_IsOK(res1)) {
15308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15309 }
15310 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 resultobj = SWIG_From_int(static_cast< int >(result));
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15325 PyObject *resultobj = 0;
15326 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15327 int result;
15328 void *argp1 = 0 ;
15329 int res1 = 0 ;
15330 PyObject *swig_obj[1] ;
15331
15332 if (!args) SWIG_fail;
15333 swig_obj[0] = args;
15334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15335 if (!SWIG_IsOK(res1)) {
15336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15337 }
15338 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 resultobj = SWIG_From_int(static_cast< int >(result));
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15353 PyObject *resultobj = 0;
15354 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15355 int result;
15356 void *argp1 = 0 ;
15357 int res1 = 0 ;
15358 PyObject *swig_obj[1] ;
15359
15360 if (!args) SWIG_fail;
15361 swig_obj[0] = args;
15362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15365 }
15366 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 resultobj = SWIG_From_int(static_cast< int >(result));
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15381 PyObject *resultobj = 0;
15382 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15383 int result;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject *swig_obj[1] ;
15387
15388 if (!args) SWIG_fail;
15389 swig_obj[0] = args;
15390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15393 }
15394 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15398 wxPyEndAllowThreads(__tstate);
15399 if (PyErr_Occurred()) SWIG_fail;
15400 }
15401 resultobj = SWIG_From_int(static_cast< int >(result));
15402 return resultobj;
15403 fail:
15404 return NULL;
15405 }
15406
15407
15408 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15409 PyObject *resultobj = 0;
15410 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15411 int arg2 ;
15412 void *argp1 = 0 ;
15413 int res1 = 0 ;
15414 int val2 ;
15415 int ecode2 = 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "self",(char *) "stick", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15426 }
15427 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15428 ecode2 = SWIG_AsVal_int(obj1, &val2);
15429 if (!SWIG_IsOK(ecode2)) {
15430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15431 }
15432 arg2 = static_cast< int >(val2);
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 (arg1)->SetJoystick(arg2);
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 resultobj = SWIG_Py_Void();
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj = 0;
15448 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15449 int arg2 ;
15450 void *argp1 = 0 ;
15451 int res1 = 0 ;
15452 int val2 ;
15453 int ecode2 = 0 ;
15454 PyObject * obj0 = 0 ;
15455 PyObject * obj1 = 0 ;
15456 char * kwnames[] = {
15457 (char *) "self",(char *) "state", NULL
15458 };
15459
15460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15464 }
15465 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15466 ecode2 = SWIG_AsVal_int(obj1, &val2);
15467 if (!SWIG_IsOK(ecode2)) {
15468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15469 }
15470 arg2 = static_cast< int >(val2);
15471 {
15472 PyThreadState* __tstate = wxPyBeginAllowThreads();
15473 (arg1)->SetButtonState(arg2);
15474 wxPyEndAllowThreads(__tstate);
15475 if (PyErr_Occurred()) SWIG_fail;
15476 }
15477 resultobj = SWIG_Py_Void();
15478 return resultobj;
15479 fail:
15480 return NULL;
15481 }
15482
15483
15484 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj = 0;
15486 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15487 int arg2 ;
15488 void *argp1 = 0 ;
15489 int res1 = 0 ;
15490 int val2 ;
15491 int ecode2 = 0 ;
15492 PyObject * obj0 = 0 ;
15493 PyObject * obj1 = 0 ;
15494 char * kwnames[] = {
15495 (char *) "self",(char *) "change", NULL
15496 };
15497
15498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15500 if (!SWIG_IsOK(res1)) {
15501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15502 }
15503 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15504 ecode2 = SWIG_AsVal_int(obj1, &val2);
15505 if (!SWIG_IsOK(ecode2)) {
15506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15507 }
15508 arg2 = static_cast< int >(val2);
15509 {
15510 PyThreadState* __tstate = wxPyBeginAllowThreads();
15511 (arg1)->SetButtonChange(arg2);
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15523 PyObject *resultobj = 0;
15524 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15525 wxPoint *arg2 = 0 ;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 wxPoint temp2 ;
15529 PyObject * obj0 = 0 ;
15530 PyObject * obj1 = 0 ;
15531 char * kwnames[] = {
15532 (char *) "self",(char *) "pos", NULL
15533 };
15534
15535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15537 if (!SWIG_IsOK(res1)) {
15538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15539 }
15540 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15541 {
15542 arg2 = &temp2;
15543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15544 }
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 (arg1)->SetPosition((wxPoint const &)*arg2);
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 resultobj = SWIG_Py_Void();
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15559 PyObject *resultobj = 0;
15560 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15561 int arg2 ;
15562 void *argp1 = 0 ;
15563 int res1 = 0 ;
15564 int val2 ;
15565 int ecode2 = 0 ;
15566 PyObject * obj0 = 0 ;
15567 PyObject * obj1 = 0 ;
15568 char * kwnames[] = {
15569 (char *) "self",(char *) "zPos", NULL
15570 };
15571
15572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15574 if (!SWIG_IsOK(res1)) {
15575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15576 }
15577 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15578 ecode2 = SWIG_AsVal_int(obj1, &val2);
15579 if (!SWIG_IsOK(ecode2)) {
15580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15581 }
15582 arg2 = static_cast< int >(val2);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 (arg1)->SetZPosition(arg2);
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_Py_Void();
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15599 bool result;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 PyObject *swig_obj[1] ;
15603
15604 if (!args) SWIG_fail;
15605 swig_obj[0] = args;
15606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15609 }
15610 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15614 wxPyEndAllowThreads(__tstate);
15615 if (PyErr_Occurred()) SWIG_fail;
15616 }
15617 {
15618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15619 }
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15627 PyObject *resultobj = 0;
15628 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15629 bool result;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 PyObject *swig_obj[1] ;
15633
15634 if (!args) SWIG_fail;
15635 swig_obj[0] = args;
15636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15637 if (!SWIG_IsOK(res1)) {
15638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15639 }
15640 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15641 {
15642 PyThreadState* __tstate = wxPyBeginAllowThreads();
15643 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15644 wxPyEndAllowThreads(__tstate);
15645 if (PyErr_Occurred()) SWIG_fail;
15646 }
15647 {
15648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15649 }
15650 return resultobj;
15651 fail:
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15659 bool result;
15660 void *argp1 = 0 ;
15661 int res1 = 0 ;
15662 PyObject *swig_obj[1] ;
15663
15664 if (!args) SWIG_fail;
15665 swig_obj[0] = args;
15666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15667 if (!SWIG_IsOK(res1)) {
15668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15669 }
15670 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 {
15678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15679 }
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15687 PyObject *resultobj = 0;
15688 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15689 int arg2 = (int) wxJOY_BUTTON_ANY ;
15690 bool result;
15691 void *argp1 = 0 ;
15692 int res1 = 0 ;
15693 int val2 ;
15694 int ecode2 = 0 ;
15695 PyObject * obj0 = 0 ;
15696 PyObject * obj1 = 0 ;
15697 char * kwnames[] = {
15698 (char *) "self",(char *) "but", NULL
15699 };
15700
15701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15703 if (!SWIG_IsOK(res1)) {
15704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15705 }
15706 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15707 if (obj1) {
15708 ecode2 = SWIG_AsVal_int(obj1, &val2);
15709 if (!SWIG_IsOK(ecode2)) {
15710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15711 }
15712 arg2 = static_cast< int >(val2);
15713 }
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 {
15721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15722 }
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15730 PyObject *resultobj = 0;
15731 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15732 int arg2 = (int) wxJOY_BUTTON_ANY ;
15733 bool result;
15734 void *argp1 = 0 ;
15735 int res1 = 0 ;
15736 int val2 ;
15737 int ecode2 = 0 ;
15738 PyObject * obj0 = 0 ;
15739 PyObject * obj1 = 0 ;
15740 char * kwnames[] = {
15741 (char *) "self",(char *) "but", NULL
15742 };
15743
15744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15746 if (!SWIG_IsOK(res1)) {
15747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15748 }
15749 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15750 if (obj1) {
15751 ecode2 = SWIG_AsVal_int(obj1, &val2);
15752 if (!SWIG_IsOK(ecode2)) {
15753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15754 }
15755 arg2 = static_cast< int >(val2);
15756 }
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15760 wxPyEndAllowThreads(__tstate);
15761 if (PyErr_Occurred()) SWIG_fail;
15762 }
15763 {
15764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15765 }
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj = 0;
15774 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15775 int arg2 = (int) wxJOY_BUTTON_ANY ;
15776 bool result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 int val2 ;
15780 int ecode2 = 0 ;
15781 PyObject * obj0 = 0 ;
15782 PyObject * obj1 = 0 ;
15783 char * kwnames[] = {
15784 (char *) "self",(char *) "but", NULL
15785 };
15786
15787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15789 if (!SWIG_IsOK(res1)) {
15790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15791 }
15792 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15793 if (obj1) {
15794 ecode2 = SWIG_AsVal_int(obj1, &val2);
15795 if (!SWIG_IsOK(ecode2)) {
15796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15797 }
15798 arg2 = static_cast< int >(val2);
15799 }
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 {
15807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15808 }
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15816 PyObject *obj;
15817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15818 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15819 return SWIG_Py_Void();
15820 }
15821
15822 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15823 return SWIG_Python_InitShadowInstance(args);
15824 }
15825
15826 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15827 PyObject *resultobj = 0;
15828 wxString const &arg1_defvalue = wxPyEmptyString ;
15829 wxString *arg1 = (wxString *) &arg1_defvalue ;
15830 wxSound *result = 0 ;
15831 bool temp1 = false ;
15832 PyObject * obj0 = 0 ;
15833 char * kwnames[] = {
15834 (char *) "fileName", NULL
15835 };
15836
15837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15838 if (obj0) {
15839 {
15840 arg1 = wxString_in_helper(obj0);
15841 if (arg1 == NULL) SWIG_fail;
15842 temp1 = true;
15843 }
15844 }
15845 {
15846 if (!wxPyCheckForApp()) SWIG_fail;
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15853 {
15854 if (temp1)
15855 delete arg1;
15856 }
15857 return resultobj;
15858 fail:
15859 {
15860 if (temp1)
15861 delete arg1;
15862 }
15863 return NULL;
15864 }
15865
15866
15867 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj = 0;
15869 PyObject *arg1 = (PyObject *) 0 ;
15870 wxSound *result = 0 ;
15871 PyObject * obj0 = 0 ;
15872 char * kwnames[] = {
15873 (char *) "data", NULL
15874 };
15875
15876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15877 arg1 = obj0;
15878 {
15879 if (!wxPyCheckForApp()) SWIG_fail;
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = (wxSound *)new_wxSound(arg1);
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15886 return resultobj;
15887 fail:
15888 return NULL;
15889 }
15890
15891
15892 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15893 PyObject *resultobj = 0;
15894 wxSound *arg1 = (wxSound *) 0 ;
15895 void *argp1 = 0 ;
15896 int res1 = 0 ;
15897 PyObject *swig_obj[1] ;
15898
15899 if (!args) SWIG_fail;
15900 swig_obj[0] = args;
15901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15902 if (!SWIG_IsOK(res1)) {
15903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15904 }
15905 arg1 = reinterpret_cast< wxSound * >(argp1);
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 delete arg1;
15909
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_Py_Void();
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxSound *arg1 = (wxSound *) 0 ;
15923 wxString *arg2 = 0 ;
15924 bool result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 bool temp2 = false ;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "self",(char *) "fileName", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15938 }
15939 arg1 = reinterpret_cast< wxSound * >(argp1);
15940 {
15941 arg2 = wxString_in_helper(obj1);
15942 if (arg2 == NULL) SWIG_fail;
15943 temp2 = true;
15944 }
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 result = (bool)(arg1)->Create((wxString const &)*arg2);
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 {
15952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15953 }
15954 {
15955 if (temp2)
15956 delete arg2;
15957 }
15958 return resultobj;
15959 fail:
15960 {
15961 if (temp2)
15962 delete arg2;
15963 }
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxSound *arg1 = (wxSound *) 0 ;
15971 PyObject *arg2 = (PyObject *) 0 ;
15972 bool result;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 PyObject * obj0 = 0 ;
15976 PyObject * obj1 = 0 ;
15977 char * kwnames[] = {
15978 (char *) "self",(char *) "data", NULL
15979 };
15980
15981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15983 if (!SWIG_IsOK(res1)) {
15984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15985 }
15986 arg1 = reinterpret_cast< wxSound * >(argp1);
15987 arg2 = obj1;
15988 {
15989 PyThreadState* __tstate = wxPyBeginAllowThreads();
15990 result = (bool)wxSound_CreateFromData(arg1,arg2);
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 {
15995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15996 }
15997 return resultobj;
15998 fail:
15999 return NULL;
16000 }
16001
16002
16003 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16004 PyObject *resultobj = 0;
16005 wxSound *arg1 = (wxSound *) 0 ;
16006 bool result;
16007 void *argp1 = 0 ;
16008 int res1 = 0 ;
16009 PyObject *swig_obj[1] ;
16010
16011 if (!args) SWIG_fail;
16012 swig_obj[0] = args;
16013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16014 if (!SWIG_IsOK(res1)) {
16015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16016 }
16017 arg1 = reinterpret_cast< wxSound * >(argp1);
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 result = (bool)(arg1)->IsOk();
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 {
16025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16026 }
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = 0;
16035 wxSound *arg1 = (wxSound *) 0 ;
16036 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16037 bool result;
16038 void *argp1 = 0 ;
16039 int res1 = 0 ;
16040 unsigned int val2 ;
16041 int ecode2 = 0 ;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 char * kwnames[] = {
16045 (char *) "self",(char *) "flags", NULL
16046 };
16047
16048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16050 if (!SWIG_IsOK(res1)) {
16051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16052 }
16053 arg1 = reinterpret_cast< wxSound * >(argp1);
16054 if (obj1) {
16055 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16056 if (!SWIG_IsOK(ecode2)) {
16057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16058 }
16059 arg2 = static_cast< unsigned int >(val2);
16060 }
16061 {
16062 if (!wxPyCheckForApp()) SWIG_fail;
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 result = (bool)((wxSound const *)arg1)->Play(arg2);
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 {
16069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16070 }
16071 return resultobj;
16072 fail:
16073 return NULL;
16074 }
16075
16076
16077 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16078 PyObject *resultobj = 0;
16079 wxString *arg1 = 0 ;
16080 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16081 bool result;
16082 bool temp1 = false ;
16083 unsigned int val2 ;
16084 int ecode2 = 0 ;
16085 PyObject * obj0 = 0 ;
16086 PyObject * obj1 = 0 ;
16087 char * kwnames[] = {
16088 (char *) "filename",(char *) "flags", NULL
16089 };
16090
16091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16092 {
16093 arg1 = wxString_in_helper(obj0);
16094 if (arg1 == NULL) SWIG_fail;
16095 temp1 = true;
16096 }
16097 if (obj1) {
16098 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16099 if (!SWIG_IsOK(ecode2)) {
16100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16101 }
16102 arg2 = static_cast< unsigned int >(val2);
16103 }
16104 {
16105 if (!wxPyCheckForApp()) SWIG_fail;
16106 PyThreadState* __tstate = wxPyBeginAllowThreads();
16107 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 {
16112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16113 }
16114 {
16115 if (temp1)
16116 delete arg1;
16117 }
16118 return resultobj;
16119 fail:
16120 {
16121 if (temp1)
16122 delete arg1;
16123 }
16124 return NULL;
16125 }
16126
16127
16128 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16129 PyObject *resultobj = 0;
16130
16131 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16132 {
16133 if (!wxPyCheckForApp()) SWIG_fail;
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 wxSound::Stop();
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 resultobj = SWIG_Py_Void();
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16147 PyObject *obj;
16148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16149 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16150 return SWIG_Py_Void();
16151 }
16152
16153 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16154 return SWIG_Python_InitShadowInstance(args);
16155 }
16156
16157 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj = 0;
16159 wxString *arg1 = 0 ;
16160 wxString *arg2 = 0 ;
16161 wxString *arg3 = 0 ;
16162 wxString *arg4 = 0 ;
16163 wxFileTypeInfo *result = 0 ;
16164 bool temp1 = false ;
16165 bool temp2 = false ;
16166 bool temp3 = false ;
16167 bool temp4 = false ;
16168 PyObject * obj0 = 0 ;
16169 PyObject * obj1 = 0 ;
16170 PyObject * obj2 = 0 ;
16171 PyObject * obj3 = 0 ;
16172 char * kwnames[] = {
16173 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16174 };
16175
16176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16177 {
16178 arg1 = wxString_in_helper(obj0);
16179 if (arg1 == NULL) SWIG_fail;
16180 temp1 = true;
16181 }
16182 {
16183 arg2 = wxString_in_helper(obj1);
16184 if (arg2 == NULL) SWIG_fail;
16185 temp2 = true;
16186 }
16187 {
16188 arg3 = wxString_in_helper(obj2);
16189 if (arg3 == NULL) SWIG_fail;
16190 temp3 = true;
16191 }
16192 {
16193 arg4 = wxString_in_helper(obj3);
16194 if (arg4 == NULL) SWIG_fail;
16195 temp4 = true;
16196 }
16197 {
16198 PyThreadState* __tstate = wxPyBeginAllowThreads();
16199 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16200 wxPyEndAllowThreads(__tstate);
16201 if (PyErr_Occurred()) SWIG_fail;
16202 }
16203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16204 {
16205 if (temp1)
16206 delete arg1;
16207 }
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 {
16213 if (temp3)
16214 delete arg3;
16215 }
16216 {
16217 if (temp4)
16218 delete arg4;
16219 }
16220 return resultobj;
16221 fail:
16222 {
16223 if (temp1)
16224 delete arg1;
16225 }
16226 {
16227 if (temp2)
16228 delete arg2;
16229 }
16230 {
16231 if (temp3)
16232 delete arg3;
16233 }
16234 {
16235 if (temp4)
16236 delete arg4;
16237 }
16238 return NULL;
16239 }
16240
16241
16242 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj = 0;
16244 wxArrayString *arg1 = 0 ;
16245 wxFileTypeInfo *result = 0 ;
16246 bool temp1 = false ;
16247 PyObject * obj0 = 0 ;
16248 char * kwnames[] = {
16249 (char *) "sArray", NULL
16250 };
16251
16252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16253 {
16254 if (! PySequence_Check(obj0)) {
16255 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16256 SWIG_fail;
16257 }
16258 arg1 = new wxArrayString;
16259 temp1 = true;
16260 int i, len=PySequence_Length(obj0);
16261 for (i=0; i<len; i++) {
16262 PyObject* item = PySequence_GetItem(obj0, i);
16263 wxString* s = wxString_in_helper(item);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 arg1->Add(*s);
16266 delete s;
16267 Py_DECREF(item);
16268 }
16269 }
16270 {
16271 PyThreadState* __tstate = wxPyBeginAllowThreads();
16272 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16277 {
16278 if (temp1) delete arg1;
16279 }
16280 return resultobj;
16281 fail:
16282 {
16283 if (temp1) delete arg1;
16284 }
16285 return NULL;
16286 }
16287
16288
16289 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290 PyObject *resultobj = 0;
16291 wxFileTypeInfo *result = 0 ;
16292
16293 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16294 {
16295 PyThreadState* __tstate = wxPyBeginAllowThreads();
16296 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16301 return resultobj;
16302 fail:
16303 return NULL;
16304 }
16305
16306
16307 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16308 PyObject *resultobj = 0;
16309 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16310 bool result;
16311 void *argp1 = 0 ;
16312 int res1 = 0 ;
16313 PyObject *swig_obj[1] ;
16314
16315 if (!args) SWIG_fail;
16316 swig_obj[0] = args;
16317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16318 if (!SWIG_IsOK(res1)) {
16319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16320 }
16321 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16322 {
16323 PyThreadState* __tstate = wxPyBeginAllowThreads();
16324 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 {
16329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16330 }
16331 return resultobj;
16332 fail:
16333 return NULL;
16334 }
16335
16336
16337 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj = 0;
16339 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16340 wxString *arg2 = 0 ;
16341 int arg3 = (int) 0 ;
16342 void *argp1 = 0 ;
16343 int res1 = 0 ;
16344 bool temp2 = false ;
16345 int val3 ;
16346 int ecode3 = 0 ;
16347 PyObject * obj0 = 0 ;
16348 PyObject * obj1 = 0 ;
16349 PyObject * obj2 = 0 ;
16350 char * kwnames[] = {
16351 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16352 };
16353
16354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16356 if (!SWIG_IsOK(res1)) {
16357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16358 }
16359 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16360 {
16361 arg2 = wxString_in_helper(obj1);
16362 if (arg2 == NULL) SWIG_fail;
16363 temp2 = true;
16364 }
16365 if (obj2) {
16366 ecode3 = SWIG_AsVal_int(obj2, &val3);
16367 if (!SWIG_IsOK(ecode3)) {
16368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16369 }
16370 arg3 = static_cast< int >(val3);
16371 }
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 resultobj = SWIG_Py_Void();
16379 {
16380 if (temp2)
16381 delete arg2;
16382 }
16383 return resultobj;
16384 fail:
16385 {
16386 if (temp2)
16387 delete arg2;
16388 }
16389 return NULL;
16390 }
16391
16392
16393 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj = 0;
16395 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16396 wxString *arg2 = 0 ;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 bool temp2 = false ;
16400 PyObject * obj0 = 0 ;
16401 PyObject * obj1 = 0 ;
16402 char * kwnames[] = {
16403 (char *) "self",(char *) "shortDesc", NULL
16404 };
16405
16406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16408 if (!SWIG_IsOK(res1)) {
16409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16410 }
16411 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16412 {
16413 arg2 = wxString_in_helper(obj1);
16414 if (arg2 == NULL) SWIG_fail;
16415 temp2 = true;
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 (arg1)->SetShortDesc((wxString const &)*arg2);
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 resultobj = SWIG_Py_Void();
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16439 PyObject *resultobj = 0;
16440 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16441 wxString *result = 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 PyObject *swig_obj[1] ;
16445
16446 if (!args) SWIG_fail;
16447 swig_obj[0] = args;
16448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16449 if (!SWIG_IsOK(res1)) {
16450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16451 }
16452 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16453 {
16454 PyThreadState* __tstate = wxPyBeginAllowThreads();
16455 {
16456 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16457 result = (wxString *) &_result_ref;
16458 }
16459 wxPyEndAllowThreads(__tstate);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 }
16462 {
16463 #if wxUSE_UNICODE
16464 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16465 #else
16466 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16467 #endif
16468 }
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16476 PyObject *resultobj = 0;
16477 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16478 wxString *result = 0 ;
16479 void *argp1 = 0 ;
16480 int res1 = 0 ;
16481 PyObject *swig_obj[1] ;
16482
16483 if (!args) SWIG_fail;
16484 swig_obj[0] = args;
16485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16488 }
16489 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 {
16493 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16494 result = (wxString *) &_result_ref;
16495 }
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 {
16500 #if wxUSE_UNICODE
16501 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16502 #else
16503 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16504 #endif
16505 }
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16513 PyObject *resultobj = 0;
16514 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16515 wxString *result = 0 ;
16516 void *argp1 = 0 ;
16517 int res1 = 0 ;
16518 PyObject *swig_obj[1] ;
16519
16520 if (!args) SWIG_fail;
16521 swig_obj[0] = args;
16522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 {
16530 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16531 result = (wxString *) &_result_ref;
16532 }
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 {
16537 #if wxUSE_UNICODE
16538 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16539 #else
16540 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16541 #endif
16542 }
16543 return resultobj;
16544 fail:
16545 return NULL;
16546 }
16547
16548
16549 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16550 PyObject *resultobj = 0;
16551 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16552 wxString *result = 0 ;
16553 void *argp1 = 0 ;
16554 int res1 = 0 ;
16555 PyObject *swig_obj[1] ;
16556
16557 if (!args) SWIG_fail;
16558 swig_obj[0] = args;
16559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16560 if (!SWIG_IsOK(res1)) {
16561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16562 }
16563 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 {
16567 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16568 result = (wxString *) &_result_ref;
16569 }
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 #if wxUSE_UNICODE
16575 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16576 #else
16577 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16578 #endif
16579 }
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16587 PyObject *resultobj = 0;
16588 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16589 wxString *result = 0 ;
16590 void *argp1 = 0 ;
16591 int res1 = 0 ;
16592 PyObject *swig_obj[1] ;
16593
16594 if (!args) SWIG_fail;
16595 swig_obj[0] = args;
16596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16597 if (!SWIG_IsOK(res1)) {
16598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16599 }
16600 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 {
16604 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16605 result = (wxString *) &_result_ref;
16606 }
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 {
16611 #if wxUSE_UNICODE
16612 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16613 #else
16614 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16615 #endif
16616 }
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16624 PyObject *resultobj = 0;
16625 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16626 wxArrayString *result = 0 ;
16627 void *argp1 = 0 ;
16628 int res1 = 0 ;
16629 PyObject *swig_obj[1] ;
16630
16631 if (!args) SWIG_fail;
16632 swig_obj[0] = args;
16633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16634 if (!SWIG_IsOK(res1)) {
16635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16636 }
16637 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 {
16641 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16642 result = (wxArrayString *) &_result_ref;
16643 }
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 {
16648 resultobj = wxArrayString2PyList_helper(*result);
16649 }
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16657 PyObject *resultobj = 0;
16658 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16659 size_t result;
16660 void *argp1 = 0 ;
16661 int res1 = 0 ;
16662 PyObject *swig_obj[1] ;
16663
16664 if (!args) SWIG_fail;
16665 swig_obj[0] = args;
16666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16667 if (!SWIG_IsOK(res1)) {
16668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16669 }
16670 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16685 PyObject *resultobj = 0;
16686 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16687 wxString *result = 0 ;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 PyObject *swig_obj[1] ;
16691
16692 if (!args) SWIG_fail;
16693 swig_obj[0] = args;
16694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16695 if (!SWIG_IsOK(res1)) {
16696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16697 }
16698 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 {
16702 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16703 result = (wxString *) &_result_ref;
16704 }
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 {
16709 #if wxUSE_UNICODE
16710 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16711 #else
16712 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16713 #endif
16714 }
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16722 PyObject *resultobj = 0;
16723 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16724 int result;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 PyObject *swig_obj[1] ;
16728
16729 if (!args) SWIG_fail;
16730 swig_obj[0] = args;
16731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16732 if (!SWIG_IsOK(res1)) {
16733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16734 }
16735 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 resultobj = SWIG_From_int(static_cast< int >(result));
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16750 PyObject *obj;
16751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16752 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16753 return SWIG_Py_Void();
16754 }
16755
16756 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16757 return SWIG_Python_InitShadowInstance(args);
16758 }
16759
16760 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj = 0;
16762 wxFileTypeInfo *arg1 = 0 ;
16763 wxFileType *result = 0 ;
16764 void *argp1 = 0 ;
16765 int res1 = 0 ;
16766 PyObject * obj0 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "ftInfo", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16775 }
16776 if (!argp1) {
16777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16778 }
16779 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16794 PyObject *resultobj = 0;
16795 wxFileType *arg1 = (wxFileType *) 0 ;
16796 void *argp1 = 0 ;
16797 int res1 = 0 ;
16798 PyObject *swig_obj[1] ;
16799
16800 if (!args) SWIG_fail;
16801 swig_obj[0] = args;
16802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16803 if (!SWIG_IsOK(res1)) {
16804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16805 }
16806 arg1 = reinterpret_cast< wxFileType * >(argp1);
16807 {
16808 PyThreadState* __tstate = wxPyBeginAllowThreads();
16809 delete arg1;
16810
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_Py_Void();
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16822 PyObject *resultobj = 0;
16823 wxFileType *arg1 = (wxFileType *) 0 ;
16824 PyObject *result = 0 ;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 PyObject *swig_obj[1] ;
16828
16829 if (!args) SWIG_fail;
16830 swig_obj[0] = args;
16831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16834 }
16835 arg1 = reinterpret_cast< wxFileType * >(argp1);
16836 {
16837 PyThreadState* __tstate = wxPyBeginAllowThreads();
16838 result = (PyObject *)wxFileType_GetMimeType(arg1);
16839 wxPyEndAllowThreads(__tstate);
16840 if (PyErr_Occurred()) SWIG_fail;
16841 }
16842 resultobj = result;
16843 return resultobj;
16844 fail:
16845 return NULL;
16846 }
16847
16848
16849 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16850 PyObject *resultobj = 0;
16851 wxFileType *arg1 = (wxFileType *) 0 ;
16852 PyObject *result = 0 ;
16853 void *argp1 = 0 ;
16854 int res1 = 0 ;
16855 PyObject *swig_obj[1] ;
16856
16857 if (!args) SWIG_fail;
16858 swig_obj[0] = args;
16859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16860 if (!SWIG_IsOK(res1)) {
16861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16862 }
16863 arg1 = reinterpret_cast< wxFileType * >(argp1);
16864 {
16865 PyThreadState* __tstate = wxPyBeginAllowThreads();
16866 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 resultobj = result;
16871 return resultobj;
16872 fail:
16873 return NULL;
16874 }
16875
16876
16877 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16878 PyObject *resultobj = 0;
16879 wxFileType *arg1 = (wxFileType *) 0 ;
16880 PyObject *result = 0 ;
16881 void *argp1 = 0 ;
16882 int res1 = 0 ;
16883 PyObject *swig_obj[1] ;
16884
16885 if (!args) SWIG_fail;
16886 swig_obj[0] = args;
16887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16888 if (!SWIG_IsOK(res1)) {
16889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16890 }
16891 arg1 = reinterpret_cast< wxFileType * >(argp1);
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = (PyObject *)wxFileType_GetExtensions(arg1);
16895 wxPyEndAllowThreads(__tstate);
16896 if (PyErr_Occurred()) SWIG_fail;
16897 }
16898 resultobj = result;
16899 return resultobj;
16900 fail:
16901 return NULL;
16902 }
16903
16904
16905 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16906 PyObject *resultobj = 0;
16907 wxFileType *arg1 = (wxFileType *) 0 ;
16908 wxIcon *result = 0 ;
16909 void *argp1 = 0 ;
16910 int res1 = 0 ;
16911 PyObject *swig_obj[1] ;
16912
16913 if (!args) SWIG_fail;
16914 swig_obj[0] = args;
16915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16916 if (!SWIG_IsOK(res1)) {
16917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16918 }
16919 arg1 = reinterpret_cast< wxFileType * >(argp1);
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (wxIcon *)wxFileType_GetIcon(arg1);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16934 PyObject *resultobj = 0;
16935 wxFileType *arg1 = (wxFileType *) 0 ;
16936 PyObject *result = 0 ;
16937 void *argp1 = 0 ;
16938 int res1 = 0 ;
16939 PyObject *swig_obj[1] ;
16940
16941 if (!args) SWIG_fail;
16942 swig_obj[0] = args;
16943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16946 }
16947 arg1 = reinterpret_cast< wxFileType * >(argp1);
16948 {
16949 PyThreadState* __tstate = wxPyBeginAllowThreads();
16950 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 resultobj = result;
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16962 PyObject *resultobj = 0;
16963 wxFileType *arg1 = (wxFileType *) 0 ;
16964 PyObject *result = 0 ;
16965 void *argp1 = 0 ;
16966 int res1 = 0 ;
16967 PyObject *swig_obj[1] ;
16968
16969 if (!args) SWIG_fail;
16970 swig_obj[0] = args;
16971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16972 if (!SWIG_IsOK(res1)) {
16973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16974 }
16975 arg1 = reinterpret_cast< wxFileType * >(argp1);
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (PyObject *)wxFileType_GetDescription(arg1);
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = result;
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16990 PyObject *resultobj = 0;
16991 wxFileType *arg1 = (wxFileType *) 0 ;
16992 wxString *arg2 = 0 ;
16993 wxString const &arg3_defvalue = wxPyEmptyString ;
16994 wxString *arg3 = (wxString *) &arg3_defvalue ;
16995 PyObject *result = 0 ;
16996 void *argp1 = 0 ;
16997 int res1 = 0 ;
16998 bool temp2 = false ;
16999 bool temp3 = false ;
17000 PyObject * obj0 = 0 ;
17001 PyObject * obj1 = 0 ;
17002 PyObject * obj2 = 0 ;
17003 char * kwnames[] = {
17004 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17005 };
17006
17007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17009 if (!SWIG_IsOK(res1)) {
17010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17011 }
17012 arg1 = reinterpret_cast< wxFileType * >(argp1);
17013 {
17014 arg2 = wxString_in_helper(obj1);
17015 if (arg2 == NULL) SWIG_fail;
17016 temp2 = true;
17017 }
17018 if (obj2) {
17019 {
17020 arg3 = wxString_in_helper(obj2);
17021 if (arg3 == NULL) SWIG_fail;
17022 temp3 = true;
17023 }
17024 }
17025 {
17026 PyThreadState* __tstate = wxPyBeginAllowThreads();
17027 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17028 wxPyEndAllowThreads(__tstate);
17029 if (PyErr_Occurred()) SWIG_fail;
17030 }
17031 resultobj = result;
17032 {
17033 if (temp2)
17034 delete arg2;
17035 }
17036 {
17037 if (temp3)
17038 delete arg3;
17039 }
17040 return resultobj;
17041 fail:
17042 {
17043 if (temp2)
17044 delete arg2;
17045 }
17046 {
17047 if (temp3)
17048 delete arg3;
17049 }
17050 return NULL;
17051 }
17052
17053
17054 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj = 0;
17056 wxFileType *arg1 = (wxFileType *) 0 ;
17057 wxString *arg2 = 0 ;
17058 wxString const &arg3_defvalue = wxPyEmptyString ;
17059 wxString *arg3 = (wxString *) &arg3_defvalue ;
17060 PyObject *result = 0 ;
17061 void *argp1 = 0 ;
17062 int res1 = 0 ;
17063 bool temp2 = false ;
17064 bool temp3 = false ;
17065 PyObject * obj0 = 0 ;
17066 PyObject * obj1 = 0 ;
17067 PyObject * obj2 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17074 if (!SWIG_IsOK(res1)) {
17075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17076 }
17077 arg1 = reinterpret_cast< wxFileType * >(argp1);
17078 {
17079 arg2 = wxString_in_helper(obj1);
17080 if (arg2 == NULL) SWIG_fail;
17081 temp2 = true;
17082 }
17083 if (obj2) {
17084 {
17085 arg3 = wxString_in_helper(obj2);
17086 if (arg3 == NULL) SWIG_fail;
17087 temp3 = true;
17088 }
17089 }
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 resultobj = result;
17097 {
17098 if (temp2)
17099 delete arg2;
17100 }
17101 {
17102 if (temp3)
17103 delete arg3;
17104 }
17105 return resultobj;
17106 fail:
17107 {
17108 if (temp2)
17109 delete arg2;
17110 }
17111 {
17112 if (temp3)
17113 delete arg3;
17114 }
17115 return NULL;
17116 }
17117
17118
17119 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17120 PyObject *resultobj = 0;
17121 wxFileType *arg1 = (wxFileType *) 0 ;
17122 wxString *arg2 = 0 ;
17123 wxString const &arg3_defvalue = wxPyEmptyString ;
17124 wxString *arg3 = (wxString *) &arg3_defvalue ;
17125 PyObject *result = 0 ;
17126 void *argp1 = 0 ;
17127 int res1 = 0 ;
17128 bool temp2 = false ;
17129 bool temp3 = false ;
17130 PyObject * obj0 = 0 ;
17131 PyObject * obj1 = 0 ;
17132 PyObject * obj2 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17141 }
17142 arg1 = reinterpret_cast< wxFileType * >(argp1);
17143 {
17144 arg2 = wxString_in_helper(obj1);
17145 if (arg2 == NULL) SWIG_fail;
17146 temp2 = true;
17147 }
17148 if (obj2) {
17149 {
17150 arg3 = wxString_in_helper(obj2);
17151 if (arg3 == NULL) SWIG_fail;
17152 temp3 = true;
17153 }
17154 }
17155 {
17156 PyThreadState* __tstate = wxPyBeginAllowThreads();
17157 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 resultobj = result;
17162 {
17163 if (temp2)
17164 delete arg2;
17165 }
17166 {
17167 if (temp3)
17168 delete arg3;
17169 }
17170 return resultobj;
17171 fail:
17172 {
17173 if (temp2)
17174 delete arg2;
17175 }
17176 {
17177 if (temp3)
17178 delete arg3;
17179 }
17180 return NULL;
17181 }
17182
17183
17184 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj = 0;
17186 wxFileType *arg1 = (wxFileType *) 0 ;
17187 wxString *arg2 = 0 ;
17188 wxString *arg3 = 0 ;
17189 bool arg4 = (bool) true ;
17190 bool result;
17191 void *argp1 = 0 ;
17192 int res1 = 0 ;
17193 bool temp2 = false ;
17194 bool temp3 = false ;
17195 bool val4 ;
17196 int ecode4 = 0 ;
17197 PyObject * obj0 = 0 ;
17198 PyObject * obj1 = 0 ;
17199 PyObject * obj2 = 0 ;
17200 PyObject * obj3 = 0 ;
17201 char * kwnames[] = {
17202 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17203 };
17204
17205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17207 if (!SWIG_IsOK(res1)) {
17208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17209 }
17210 arg1 = reinterpret_cast< wxFileType * >(argp1);
17211 {
17212 arg2 = wxString_in_helper(obj1);
17213 if (arg2 == NULL) SWIG_fail;
17214 temp2 = true;
17215 }
17216 {
17217 arg3 = wxString_in_helper(obj2);
17218 if (arg3 == NULL) SWIG_fail;
17219 temp3 = true;
17220 }
17221 if (obj3) {
17222 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17223 if (!SWIG_IsOK(ecode4)) {
17224 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17225 }
17226 arg4 = static_cast< bool >(val4);
17227 }
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17231 wxPyEndAllowThreads(__tstate);
17232 if (PyErr_Occurred()) SWIG_fail;
17233 }
17234 {
17235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17236 }
17237 {
17238 if (temp2)
17239 delete arg2;
17240 }
17241 {
17242 if (temp3)
17243 delete arg3;
17244 }
17245 return resultobj;
17246 fail:
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 {
17252 if (temp3)
17253 delete arg3;
17254 }
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj = 0;
17261 wxFileType *arg1 = (wxFileType *) 0 ;
17262 wxString const &arg2_defvalue = wxPyEmptyString ;
17263 wxString *arg2 = (wxString *) &arg2_defvalue ;
17264 int arg3 = (int) 0 ;
17265 bool result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 bool temp2 = false ;
17269 int val3 ;
17270 int ecode3 = 0 ;
17271 PyObject * obj0 = 0 ;
17272 PyObject * obj1 = 0 ;
17273 PyObject * obj2 = 0 ;
17274 char * kwnames[] = {
17275 (char *) "self",(char *) "cmd",(char *) "index", NULL
17276 };
17277
17278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17280 if (!SWIG_IsOK(res1)) {
17281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17282 }
17283 arg1 = reinterpret_cast< wxFileType * >(argp1);
17284 if (obj1) {
17285 {
17286 arg2 = wxString_in_helper(obj1);
17287 if (arg2 == NULL) SWIG_fail;
17288 temp2 = true;
17289 }
17290 }
17291 if (obj2) {
17292 ecode3 = SWIG_AsVal_int(obj2, &val3);
17293 if (!SWIG_IsOK(ecode3)) {
17294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17295 }
17296 arg3 = static_cast< int >(val3);
17297 }
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 {
17305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17306 }
17307 {
17308 if (temp2)
17309 delete arg2;
17310 }
17311 return resultobj;
17312 fail:
17313 {
17314 if (temp2)
17315 delete arg2;
17316 }
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *resultobj = 0;
17323 wxFileType *arg1 = (wxFileType *) 0 ;
17324 bool result;
17325 void *argp1 = 0 ;
17326 int res1 = 0 ;
17327 PyObject *swig_obj[1] ;
17328
17329 if (!args) SWIG_fail;
17330 swig_obj[0] = args;
17331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17332 if (!SWIG_IsOK(res1)) {
17333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17334 }
17335 arg1 = reinterpret_cast< wxFileType * >(argp1);
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (bool)(arg1)->Unassociate();
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 {
17343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17344 }
17345 return resultobj;
17346 fail:
17347 return NULL;
17348 }
17349
17350
17351 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17352 PyObject *resultobj = 0;
17353 wxString *arg1 = 0 ;
17354 wxString *arg2 = 0 ;
17355 wxString const &arg3_defvalue = wxPyEmptyString ;
17356 wxString *arg3 = (wxString *) &arg3_defvalue ;
17357 wxString result;
17358 bool temp1 = false ;
17359 bool temp2 = false ;
17360 bool temp3 = false ;
17361 PyObject * obj0 = 0 ;
17362 PyObject * obj1 = 0 ;
17363 PyObject * obj2 = 0 ;
17364 char * kwnames[] = {
17365 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17366 };
17367
17368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17369 {
17370 arg1 = wxString_in_helper(obj0);
17371 if (arg1 == NULL) SWIG_fail;
17372 temp1 = true;
17373 }
17374 {
17375 arg2 = wxString_in_helper(obj1);
17376 if (arg2 == NULL) SWIG_fail;
17377 temp2 = true;
17378 }
17379 if (obj2) {
17380 {
17381 arg3 = wxString_in_helper(obj2);
17382 if (arg3 == NULL) SWIG_fail;
17383 temp3 = true;
17384 }
17385 }
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 #if wxUSE_UNICODE
17394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17395 #else
17396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17397 #endif
17398 }
17399 {
17400 if (temp1)
17401 delete arg1;
17402 }
17403 {
17404 if (temp2)
17405 delete arg2;
17406 }
17407 {
17408 if (temp3)
17409 delete arg3;
17410 }
17411 return resultobj;
17412 fail:
17413 {
17414 if (temp1)
17415 delete arg1;
17416 }
17417 {
17418 if (temp2)
17419 delete arg2;
17420 }
17421 {
17422 if (temp3)
17423 delete arg3;
17424 }
17425 return NULL;
17426 }
17427
17428
17429 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 PyObject *obj;
17431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17432 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17433 return SWIG_Py_Void();
17434 }
17435
17436 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17437 return SWIG_Python_InitShadowInstance(args);
17438 }
17439
17440 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17441 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17442 return 1;
17443 }
17444
17445
17446 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17447 PyObject *pyobj = 0;
17448
17449 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17450 return pyobj;
17451 }
17452
17453
17454 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj = 0;
17456 wxString *arg1 = 0 ;
17457 wxString *arg2 = 0 ;
17458 bool result;
17459 bool temp1 = false ;
17460 bool temp2 = false ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 char * kwnames[] = {
17464 (char *) "mimeType",(char *) "wildcard", NULL
17465 };
17466
17467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17468 {
17469 arg1 = wxString_in_helper(obj0);
17470 if (arg1 == NULL) SWIG_fail;
17471 temp1 = true;
17472 }
17473 {
17474 arg2 = wxString_in_helper(obj1);
17475 if (arg2 == NULL) SWIG_fail;
17476 temp2 = true;
17477 }
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 {
17485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17486 }
17487 {
17488 if (temp1)
17489 delete arg1;
17490 }
17491 {
17492 if (temp2)
17493 delete arg2;
17494 }
17495 return resultobj;
17496 fail:
17497 {
17498 if (temp1)
17499 delete arg1;
17500 }
17501 {
17502 if (temp2)
17503 delete arg2;
17504 }
17505 return NULL;
17506 }
17507
17508
17509 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *resultobj = 0;
17511 wxMimeTypesManager *result = 0 ;
17512
17513 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = 0;
17529 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17530 int arg2 = (int) wxMAILCAP_ALL ;
17531 wxString const &arg3_defvalue = wxPyEmptyString ;
17532 wxString *arg3 = (wxString *) &arg3_defvalue ;
17533 void *argp1 = 0 ;
17534 int res1 = 0 ;
17535 int val2 ;
17536 int ecode2 = 0 ;
17537 bool temp3 = false ;
17538 PyObject * obj0 = 0 ;
17539 PyObject * obj1 = 0 ;
17540 PyObject * obj2 = 0 ;
17541 char * kwnames[] = {
17542 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17543 };
17544
17545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17547 if (!SWIG_IsOK(res1)) {
17548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17549 }
17550 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17551 if (obj1) {
17552 ecode2 = SWIG_AsVal_int(obj1, &val2);
17553 if (!SWIG_IsOK(ecode2)) {
17554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17555 }
17556 arg2 = static_cast< int >(val2);
17557 }
17558 if (obj2) {
17559 {
17560 arg3 = wxString_in_helper(obj2);
17561 if (arg3 == NULL) SWIG_fail;
17562 temp3 = true;
17563 }
17564 }
17565 {
17566 PyThreadState* __tstate = wxPyBeginAllowThreads();
17567 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17568 wxPyEndAllowThreads(__tstate);
17569 if (PyErr_Occurred()) SWIG_fail;
17570 }
17571 resultobj = SWIG_Py_Void();
17572 {
17573 if (temp3)
17574 delete arg3;
17575 }
17576 return resultobj;
17577 fail:
17578 {
17579 if (temp3)
17580 delete arg3;
17581 }
17582 return NULL;
17583 }
17584
17585
17586 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17587 PyObject *resultobj = 0;
17588 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17589 void *argp1 = 0 ;
17590 int res1 = 0 ;
17591 PyObject *swig_obj[1] ;
17592
17593 if (!args) SWIG_fail;
17594 swig_obj[0] = args;
17595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17596 if (!SWIG_IsOK(res1)) {
17597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17598 }
17599 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 (arg1)->ClearData();
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 resultobj = SWIG_Py_Void();
17607 return resultobj;
17608 fail:
17609 return NULL;
17610 }
17611
17612
17613 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj = 0;
17615 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17616 wxString *arg2 = 0 ;
17617 wxFileType *result = 0 ;
17618 void *argp1 = 0 ;
17619 int res1 = 0 ;
17620 bool temp2 = false ;
17621 PyObject * obj0 = 0 ;
17622 PyObject * obj1 = 0 ;
17623 char * kwnames[] = {
17624 (char *) "self",(char *) "ext", NULL
17625 };
17626
17627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17629 if (!SWIG_IsOK(res1)) {
17630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17631 }
17632 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17633 {
17634 arg2 = wxString_in_helper(obj1);
17635 if (arg2 == NULL) SWIG_fail;
17636 temp2 = true;
17637 }
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17645 {
17646 if (temp2)
17647 delete arg2;
17648 }
17649 return resultobj;
17650 fail:
17651 {
17652 if (temp2)
17653 delete arg2;
17654 }
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj = 0;
17661 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17662 wxString *arg2 = 0 ;
17663 wxFileType *result = 0 ;
17664 void *argp1 = 0 ;
17665 int res1 = 0 ;
17666 bool temp2 = false ;
17667 PyObject * obj0 = 0 ;
17668 PyObject * obj1 = 0 ;
17669 char * kwnames[] = {
17670 (char *) "self",(char *) "mimeType", NULL
17671 };
17672
17673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17675 if (!SWIG_IsOK(res1)) {
17676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17677 }
17678 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17679 {
17680 arg2 = wxString_in_helper(obj1);
17681 if (arg2 == NULL) SWIG_fail;
17682 temp2 = true;
17683 }
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17691 {
17692 if (temp2)
17693 delete arg2;
17694 }
17695 return resultobj;
17696 fail:
17697 {
17698 if (temp2)
17699 delete arg2;
17700 }
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = 0;
17707 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17708 wxString *arg2 = 0 ;
17709 bool arg3 = (bool) false ;
17710 bool result;
17711 void *argp1 = 0 ;
17712 int res1 = 0 ;
17713 bool temp2 = false ;
17714 bool val3 ;
17715 int ecode3 = 0 ;
17716 PyObject * obj0 = 0 ;
17717 PyObject * obj1 = 0 ;
17718 PyObject * obj2 = 0 ;
17719 char * kwnames[] = {
17720 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17721 };
17722
17723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17725 if (!SWIG_IsOK(res1)) {
17726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17727 }
17728 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17729 {
17730 arg2 = wxString_in_helper(obj1);
17731 if (arg2 == NULL) SWIG_fail;
17732 temp2 = true;
17733 }
17734 if (obj2) {
17735 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17736 if (!SWIG_IsOK(ecode3)) {
17737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17738 }
17739 arg3 = static_cast< bool >(val3);
17740 }
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 {
17748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17749 }
17750 {
17751 if (temp2)
17752 delete arg2;
17753 }
17754 return resultobj;
17755 fail:
17756 {
17757 if (temp2)
17758 delete arg2;
17759 }
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17767 wxString *arg2 = 0 ;
17768 bool result;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 bool temp2 = false ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 char * kwnames[] = {
17775 (char *) "self",(char *) "filename", NULL
17776 };
17777
17778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17780 if (!SWIG_IsOK(res1)) {
17781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17782 }
17783 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17784 {
17785 arg2 = wxString_in_helper(obj1);
17786 if (arg2 == NULL) SWIG_fail;
17787 temp2 = true;
17788 }
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17797 }
17798 {
17799 if (temp2)
17800 delete arg2;
17801 }
17802 return resultobj;
17803 fail:
17804 {
17805 if (temp2)
17806 delete arg2;
17807 }
17808 return NULL;
17809 }
17810
17811
17812 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17813 PyObject *resultobj = 0;
17814 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17815 PyObject *result = 0 ;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 PyObject *swig_obj[1] ;
17819
17820 if (!args) SWIG_fail;
17821 swig_obj[0] = args;
17822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17823 if (!SWIG_IsOK(res1)) {
17824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17825 }
17826 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 resultobj = result;
17834 return resultobj;
17835 fail:
17836 return NULL;
17837 }
17838
17839
17840 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17841 PyObject *resultobj = 0;
17842 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17843 wxFileTypeInfo *arg2 = 0 ;
17844 void *argp1 = 0 ;
17845 int res1 = 0 ;
17846 void *argp2 = 0 ;
17847 int res2 = 0 ;
17848 PyObject * obj0 = 0 ;
17849 PyObject * obj1 = 0 ;
17850 char * kwnames[] = {
17851 (char *) "self",(char *) "ft", NULL
17852 };
17853
17854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17858 }
17859 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17861 if (!SWIG_IsOK(res2)) {
17862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17863 }
17864 if (!argp2) {
17865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17866 }
17867 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 resultobj = SWIG_Py_Void();
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj = 0;
17883 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17884 wxFileTypeInfo *arg2 = 0 ;
17885 wxFileType *result = 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 void *argp2 = 0 ;
17889 int res2 = 0 ;
17890 PyObject * obj0 = 0 ;
17891 PyObject * obj1 = 0 ;
17892 char * kwnames[] = {
17893 (char *) "self",(char *) "ftInfo", NULL
17894 };
17895
17896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17898 if (!SWIG_IsOK(res1)) {
17899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17900 }
17901 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17902 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17903 if (!SWIG_IsOK(res2)) {
17904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17905 }
17906 if (!argp2) {
17907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17908 }
17909 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj = 0;
17925 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17926 wxFileType *arg2 = (wxFileType *) 0 ;
17927 bool result;
17928 void *argp1 = 0 ;
17929 int res1 = 0 ;
17930 void *argp2 = 0 ;
17931 int res2 = 0 ;
17932 PyObject * obj0 = 0 ;
17933 PyObject * obj1 = 0 ;
17934 char * kwnames[] = {
17935 (char *) "self",(char *) "ft", NULL
17936 };
17937
17938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17940 if (!SWIG_IsOK(res1)) {
17941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17942 }
17943 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17945 if (!SWIG_IsOK(res2)) {
17946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17947 }
17948 arg2 = reinterpret_cast< wxFileType * >(argp2);
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (bool)(arg1)->Unassociate(arg2);
17952 wxPyEndAllowThreads(__tstate);
17953 if (PyErr_Occurred()) SWIG_fail;
17954 }
17955 {
17956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17957 }
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17965 PyObject *resultobj = 0;
17966 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 PyObject *swig_obj[1] ;
17970
17971 if (!args) SWIG_fail;
17972 swig_obj[0] = args;
17973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17974 if (!SWIG_IsOK(res1)) {
17975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17976 }
17977 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 delete arg1;
17981
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 resultobj = SWIG_Py_Void();
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17993 PyObject *obj;
17994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17995 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17996 return SWIG_Py_Void();
17997 }
17998
17999 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18000 return SWIG_Python_InitShadowInstance(args);
18001 }
18002
18003 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18004 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18005 return 1;
18006 }
18007
18008
18009 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18010 PyObject *pyobj = 0;
18011
18012 {
18013 #if wxUSE_UNICODE
18014 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18015 #else
18016 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18017 #endif
18018 }
18019 return pyobj;
18020 }
18021
18022
18023 SWIGINTERN int ART_MENU_set(PyObject *) {
18024 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18025 return 1;
18026 }
18027
18028
18029 SWIGINTERN PyObject *ART_MENU_get(void) {
18030 PyObject *pyobj = 0;
18031
18032 {
18033 #if wxUSE_UNICODE
18034 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18035 #else
18036 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18037 #endif
18038 }
18039 return pyobj;
18040 }
18041
18042
18043 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18044 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18045 return 1;
18046 }
18047
18048
18049 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18050 PyObject *pyobj = 0;
18051
18052 {
18053 #if wxUSE_UNICODE
18054 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18055 #else
18056 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18057 #endif
18058 }
18059 return pyobj;
18060 }
18061
18062
18063 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18064 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18065 return 1;
18066 }
18067
18068
18069 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18070 PyObject *pyobj = 0;
18071
18072 {
18073 #if wxUSE_UNICODE
18074 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18075 #else
18076 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18077 #endif
18078 }
18079 return pyobj;
18080 }
18081
18082
18083 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18084 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18085 return 1;
18086 }
18087
18088
18089 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18090 PyObject *pyobj = 0;
18091
18092 {
18093 #if wxUSE_UNICODE
18094 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18095 #else
18096 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18097 #endif
18098 }
18099 return pyobj;
18100 }
18101
18102
18103 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18104 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18105 return 1;
18106 }
18107
18108
18109 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18110 PyObject *pyobj = 0;
18111
18112 {
18113 #if wxUSE_UNICODE
18114 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18115 #else
18116 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18117 #endif
18118 }
18119 return pyobj;
18120 }
18121
18122
18123 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18124 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18125 return 1;
18126 }
18127
18128
18129 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18130 PyObject *pyobj = 0;
18131
18132 {
18133 #if wxUSE_UNICODE
18134 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18135 #else
18136 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18137 #endif
18138 }
18139 return pyobj;
18140 }
18141
18142
18143 SWIGINTERN int ART_OTHER_set(PyObject *) {
18144 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18145 return 1;
18146 }
18147
18148
18149 SWIGINTERN PyObject *ART_OTHER_get(void) {
18150 PyObject *pyobj = 0;
18151
18152 {
18153 #if wxUSE_UNICODE
18154 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18155 #else
18156 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18157 #endif
18158 }
18159 return pyobj;
18160 }
18161
18162
18163 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18164 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18165 return 1;
18166 }
18167
18168
18169 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18170 PyObject *pyobj = 0;
18171
18172 {
18173 #if wxUSE_UNICODE
18174 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18175 #else
18176 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18177 #endif
18178 }
18179 return pyobj;
18180 }
18181
18182
18183 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18184 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18185 return 1;
18186 }
18187
18188
18189 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18190 PyObject *pyobj = 0;
18191
18192 {
18193 #if wxUSE_UNICODE
18194 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18195 #else
18196 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18197 #endif
18198 }
18199 return pyobj;
18200 }
18201
18202
18203 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18204 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18205 return 1;
18206 }
18207
18208
18209 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18210 PyObject *pyobj = 0;
18211
18212 {
18213 #if wxUSE_UNICODE
18214 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18215 #else
18216 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18217 #endif
18218 }
18219 return pyobj;
18220 }
18221
18222
18223 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18224 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18225 return 1;
18226 }
18227
18228
18229 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18230 PyObject *pyobj = 0;
18231
18232 {
18233 #if wxUSE_UNICODE
18234 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18235 #else
18236 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18237 #endif
18238 }
18239 return pyobj;
18240 }
18241
18242
18243 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18244 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18245 return 1;
18246 }
18247
18248
18249 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18250 PyObject *pyobj = 0;
18251
18252 {
18253 #if wxUSE_UNICODE
18254 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18255 #else
18256 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18257 #endif
18258 }
18259 return pyobj;
18260 }
18261
18262
18263 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18264 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18265 return 1;
18266 }
18267
18268
18269 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18270 PyObject *pyobj = 0;
18271
18272 {
18273 #if wxUSE_UNICODE
18274 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18275 #else
18276 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18277 #endif
18278 }
18279 return pyobj;
18280 }
18281
18282
18283 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18284 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18285 return 1;
18286 }
18287
18288
18289 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18290 PyObject *pyobj = 0;
18291
18292 {
18293 #if wxUSE_UNICODE
18294 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18295 #else
18296 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18297 #endif
18298 }
18299 return pyobj;
18300 }
18301
18302
18303 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18304 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18305 return 1;
18306 }
18307
18308
18309 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18310 PyObject *pyobj = 0;
18311
18312 {
18313 #if wxUSE_UNICODE
18314 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18315 #else
18316 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18317 #endif
18318 }
18319 return pyobj;
18320 }
18321
18322
18323 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18324 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18325 return 1;
18326 }
18327
18328
18329 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18330 PyObject *pyobj = 0;
18331
18332 {
18333 #if wxUSE_UNICODE
18334 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18335 #else
18336 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18337 #endif
18338 }
18339 return pyobj;
18340 }
18341
18342
18343 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18344 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18345 return 1;
18346 }
18347
18348
18349 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18350 PyObject *pyobj = 0;
18351
18352 {
18353 #if wxUSE_UNICODE
18354 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18355 #else
18356 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18357 #endif
18358 }
18359 return pyobj;
18360 }
18361
18362
18363 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18364 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18365 return 1;
18366 }
18367
18368
18369 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18370 PyObject *pyobj = 0;
18371
18372 {
18373 #if wxUSE_UNICODE
18374 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18375 #else
18376 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18377 #endif
18378 }
18379 return pyobj;
18380 }
18381
18382
18383 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18384 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18385 return 1;
18386 }
18387
18388
18389 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18390 PyObject *pyobj = 0;
18391
18392 {
18393 #if wxUSE_UNICODE
18394 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18395 #else
18396 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18397 #endif
18398 }
18399 return pyobj;
18400 }
18401
18402
18403 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18404 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18405 return 1;
18406 }
18407
18408
18409 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18410 PyObject *pyobj = 0;
18411
18412 {
18413 #if wxUSE_UNICODE
18414 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18415 #else
18416 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18417 #endif
18418 }
18419 return pyobj;
18420 }
18421
18422
18423 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18424 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18425 return 1;
18426 }
18427
18428
18429 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18430 PyObject *pyobj = 0;
18431
18432 {
18433 #if wxUSE_UNICODE
18434 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18435 #else
18436 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18437 #endif
18438 }
18439 return pyobj;
18440 }
18441
18442
18443 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18444 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18445 return 1;
18446 }
18447
18448
18449 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18450 PyObject *pyobj = 0;
18451
18452 {
18453 #if wxUSE_UNICODE
18454 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18455 #else
18456 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18457 #endif
18458 }
18459 return pyobj;
18460 }
18461
18462
18463 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18464 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18465 return 1;
18466 }
18467
18468
18469 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18470 PyObject *pyobj = 0;
18471
18472 {
18473 #if wxUSE_UNICODE
18474 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18475 #else
18476 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18477 #endif
18478 }
18479 return pyobj;
18480 }
18481
18482
18483 SWIGINTERN int ART_PRINT_set(PyObject *) {
18484 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18485 return 1;
18486 }
18487
18488
18489 SWIGINTERN PyObject *ART_PRINT_get(void) {
18490 PyObject *pyobj = 0;
18491
18492 {
18493 #if wxUSE_UNICODE
18494 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18495 #else
18496 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18497 #endif
18498 }
18499 return pyobj;
18500 }
18501
18502
18503 SWIGINTERN int ART_HELP_set(PyObject *) {
18504 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18505 return 1;
18506 }
18507
18508
18509 SWIGINTERN PyObject *ART_HELP_get(void) {
18510 PyObject *pyobj = 0;
18511
18512 {
18513 #if wxUSE_UNICODE
18514 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18515 #else
18516 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18517 #endif
18518 }
18519 return pyobj;
18520 }
18521
18522
18523 SWIGINTERN int ART_TIP_set(PyObject *) {
18524 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18525 return 1;
18526 }
18527
18528
18529 SWIGINTERN PyObject *ART_TIP_get(void) {
18530 PyObject *pyobj = 0;
18531
18532 {
18533 #if wxUSE_UNICODE
18534 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18535 #else
18536 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18537 #endif
18538 }
18539 return pyobj;
18540 }
18541
18542
18543 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18544 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18545 return 1;
18546 }
18547
18548
18549 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18550 PyObject *pyobj = 0;
18551
18552 {
18553 #if wxUSE_UNICODE
18554 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18555 #else
18556 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18557 #endif
18558 }
18559 return pyobj;
18560 }
18561
18562
18563 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18564 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18565 return 1;
18566 }
18567
18568
18569 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18570 PyObject *pyobj = 0;
18571
18572 {
18573 #if wxUSE_UNICODE
18574 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18575 #else
18576 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18577 #endif
18578 }
18579 return pyobj;
18580 }
18581
18582
18583 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18584 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18585 return 1;
18586 }
18587
18588
18589 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18590 PyObject *pyobj = 0;
18591
18592 {
18593 #if wxUSE_UNICODE
18594 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18595 #else
18596 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18597 #endif
18598 }
18599 return pyobj;
18600 }
18601
18602
18603 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18604 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18605 return 1;
18606 }
18607
18608
18609 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18610 PyObject *pyobj = 0;
18611
18612 {
18613 #if wxUSE_UNICODE
18614 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18615 #else
18616 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18617 #endif
18618 }
18619 return pyobj;
18620 }
18621
18622
18623 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18624 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18625 return 1;
18626 }
18627
18628
18629 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18630 PyObject *pyobj = 0;
18631
18632 {
18633 #if wxUSE_UNICODE
18634 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18635 #else
18636 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18637 #endif
18638 }
18639 return pyobj;
18640 }
18641
18642
18643 SWIGINTERN int ART_CDROM_set(PyObject *) {
18644 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18645 return 1;
18646 }
18647
18648
18649 SWIGINTERN PyObject *ART_CDROM_get(void) {
18650 PyObject *pyobj = 0;
18651
18652 {
18653 #if wxUSE_UNICODE
18654 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18655 #else
18656 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18657 #endif
18658 }
18659 return pyobj;
18660 }
18661
18662
18663 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18664 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18665 return 1;
18666 }
18667
18668
18669 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18670 PyObject *pyobj = 0;
18671
18672 {
18673 #if wxUSE_UNICODE
18674 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18675 #else
18676 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18677 #endif
18678 }
18679 return pyobj;
18680 }
18681
18682
18683 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18684 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18685 return 1;
18686 }
18687
18688
18689 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18690 PyObject *pyobj = 0;
18691
18692 {
18693 #if wxUSE_UNICODE
18694 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18695 #else
18696 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18697 #endif
18698 }
18699 return pyobj;
18700 }
18701
18702
18703 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18704 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18705 return 1;
18706 }
18707
18708
18709 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18710 PyObject *pyobj = 0;
18711
18712 {
18713 #if wxUSE_UNICODE
18714 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18715 #else
18716 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18717 #endif
18718 }
18719 return pyobj;
18720 }
18721
18722
18723 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18724 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18725 return 1;
18726 }
18727
18728
18729 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18730 PyObject *pyobj = 0;
18731
18732 {
18733 #if wxUSE_UNICODE
18734 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18735 #else
18736 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18737 #endif
18738 }
18739 return pyobj;
18740 }
18741
18742
18743 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18744 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18745 return 1;
18746 }
18747
18748
18749 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18750 PyObject *pyobj = 0;
18751
18752 {
18753 #if wxUSE_UNICODE
18754 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18755 #else
18756 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18757 #endif
18758 }
18759 return pyobj;
18760 }
18761
18762
18763 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18764 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18765 return 1;
18766 }
18767
18768
18769 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18770 PyObject *pyobj = 0;
18771
18772 {
18773 #if wxUSE_UNICODE
18774 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18775 #else
18776 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18777 #endif
18778 }
18779 return pyobj;
18780 }
18781
18782
18783 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18784 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18785 return 1;
18786 }
18787
18788
18789 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18790 PyObject *pyobj = 0;
18791
18792 {
18793 #if wxUSE_UNICODE
18794 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18795 #else
18796 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18797 #endif
18798 }
18799 return pyobj;
18800 }
18801
18802
18803 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18804 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18805 return 1;
18806 }
18807
18808
18809 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18810 PyObject *pyobj = 0;
18811
18812 {
18813 #if wxUSE_UNICODE
18814 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18815 #else
18816 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18817 #endif
18818 }
18819 return pyobj;
18820 }
18821
18822
18823 SWIGINTERN int ART_ERROR_set(PyObject *) {
18824 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18825 return 1;
18826 }
18827
18828
18829 SWIGINTERN PyObject *ART_ERROR_get(void) {
18830 PyObject *pyobj = 0;
18831
18832 {
18833 #if wxUSE_UNICODE
18834 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18835 #else
18836 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18837 #endif
18838 }
18839 return pyobj;
18840 }
18841
18842
18843 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18844 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18845 return 1;
18846 }
18847
18848
18849 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18850 PyObject *pyobj = 0;
18851
18852 {
18853 #if wxUSE_UNICODE
18854 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18855 #else
18856 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18857 #endif
18858 }
18859 return pyobj;
18860 }
18861
18862
18863 SWIGINTERN int ART_WARNING_set(PyObject *) {
18864 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18865 return 1;
18866 }
18867
18868
18869 SWIGINTERN PyObject *ART_WARNING_get(void) {
18870 PyObject *pyobj = 0;
18871
18872 {
18873 #if wxUSE_UNICODE
18874 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18875 #else
18876 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18877 #endif
18878 }
18879 return pyobj;
18880 }
18881
18882
18883 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18884 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18885 return 1;
18886 }
18887
18888
18889 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18890 PyObject *pyobj = 0;
18891
18892 {
18893 #if wxUSE_UNICODE
18894 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18895 #else
18896 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18897 #endif
18898 }
18899 return pyobj;
18900 }
18901
18902
18903 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18904 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18905 return 1;
18906 }
18907
18908
18909 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18910 PyObject *pyobj = 0;
18911
18912 {
18913 #if wxUSE_UNICODE
18914 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18915 #else
18916 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18917 #endif
18918 }
18919 return pyobj;
18920 }
18921
18922
18923 SWIGINTERN int ART_COPY_set(PyObject *) {
18924 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18925 return 1;
18926 }
18927
18928
18929 SWIGINTERN PyObject *ART_COPY_get(void) {
18930 PyObject *pyobj = 0;
18931
18932 {
18933 #if wxUSE_UNICODE
18934 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18935 #else
18936 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18937 #endif
18938 }
18939 return pyobj;
18940 }
18941
18942
18943 SWIGINTERN int ART_CUT_set(PyObject *) {
18944 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18945 return 1;
18946 }
18947
18948
18949 SWIGINTERN PyObject *ART_CUT_get(void) {
18950 PyObject *pyobj = 0;
18951
18952 {
18953 #if wxUSE_UNICODE
18954 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18955 #else
18956 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18957 #endif
18958 }
18959 return pyobj;
18960 }
18961
18962
18963 SWIGINTERN int ART_PASTE_set(PyObject *) {
18964 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18965 return 1;
18966 }
18967
18968
18969 SWIGINTERN PyObject *ART_PASTE_get(void) {
18970 PyObject *pyobj = 0;
18971
18972 {
18973 #if wxUSE_UNICODE
18974 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18975 #else
18976 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18977 #endif
18978 }
18979 return pyobj;
18980 }
18981
18982
18983 SWIGINTERN int ART_DELETE_set(PyObject *) {
18984 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18985 return 1;
18986 }
18987
18988
18989 SWIGINTERN PyObject *ART_DELETE_get(void) {
18990 PyObject *pyobj = 0;
18991
18992 {
18993 #if wxUSE_UNICODE
18994 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18995 #else
18996 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18997 #endif
18998 }
18999 return pyobj;
19000 }
19001
19002
19003 SWIGINTERN int ART_NEW_set(PyObject *) {
19004 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19005 return 1;
19006 }
19007
19008
19009 SWIGINTERN PyObject *ART_NEW_get(void) {
19010 PyObject *pyobj = 0;
19011
19012 {
19013 #if wxUSE_UNICODE
19014 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19015 #else
19016 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19017 #endif
19018 }
19019 return pyobj;
19020 }
19021
19022
19023 SWIGINTERN int ART_UNDO_set(PyObject *) {
19024 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19025 return 1;
19026 }
19027
19028
19029 SWIGINTERN PyObject *ART_UNDO_get(void) {
19030 PyObject *pyobj = 0;
19031
19032 {
19033 #if wxUSE_UNICODE
19034 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19035 #else
19036 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19037 #endif
19038 }
19039 return pyobj;
19040 }
19041
19042
19043 SWIGINTERN int ART_REDO_set(PyObject *) {
19044 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19045 return 1;
19046 }
19047
19048
19049 SWIGINTERN PyObject *ART_REDO_get(void) {
19050 PyObject *pyobj = 0;
19051
19052 {
19053 #if wxUSE_UNICODE
19054 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19055 #else
19056 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19057 #endif
19058 }
19059 return pyobj;
19060 }
19061
19062
19063 SWIGINTERN int ART_QUIT_set(PyObject *) {
19064 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19065 return 1;
19066 }
19067
19068
19069 SWIGINTERN PyObject *ART_QUIT_get(void) {
19070 PyObject *pyobj = 0;
19071
19072 {
19073 #if wxUSE_UNICODE
19074 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19075 #else
19076 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19077 #endif
19078 }
19079 return pyobj;
19080 }
19081
19082
19083 SWIGINTERN int ART_FIND_set(PyObject *) {
19084 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19085 return 1;
19086 }
19087
19088
19089 SWIGINTERN PyObject *ART_FIND_get(void) {
19090 PyObject *pyobj = 0;
19091
19092 {
19093 #if wxUSE_UNICODE
19094 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19095 #else
19096 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19097 #endif
19098 }
19099 return pyobj;
19100 }
19101
19102
19103 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19104 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19105 return 1;
19106 }
19107
19108
19109 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19110 PyObject *pyobj = 0;
19111
19112 {
19113 #if wxUSE_UNICODE
19114 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19115 #else
19116 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19117 #endif
19118 }
19119 return pyobj;
19120 }
19121
19122
19123 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19124 PyObject *resultobj = 0;
19125 wxPyArtProvider *result = 0 ;
19126
19127 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19128 {
19129 if (!wxPyCheckForApp()) SWIG_fail;
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = (wxPyArtProvider *)new wxPyArtProvider();
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19136 return resultobj;
19137 fail:
19138 return NULL;
19139 }
19140
19141
19142 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19143 PyObject *resultobj = 0;
19144 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19145 void *argp1 = 0 ;
19146 int res1 = 0 ;
19147 PyObject *swig_obj[1] ;
19148
19149 if (!args) SWIG_fail;
19150 swig_obj[0] = args;
19151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19152 if (!SWIG_IsOK(res1)) {
19153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19154 }
19155 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19156 {
19157 PyThreadState* __tstate = wxPyBeginAllowThreads();
19158 delete arg1;
19159
19160 wxPyEndAllowThreads(__tstate);
19161 if (PyErr_Occurred()) SWIG_fail;
19162 }
19163 resultobj = SWIG_Py_Void();
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj = 0;
19172 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19173 PyObject *arg2 = (PyObject *) 0 ;
19174 PyObject *arg3 = (PyObject *) 0 ;
19175 void *argp1 = 0 ;
19176 int res1 = 0 ;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 PyObject * obj2 = 0 ;
19180 char * kwnames[] = {
19181 (char *) "self",(char *) "self",(char *) "_class", NULL
19182 };
19183
19184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19188 }
19189 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19190 arg2 = obj1;
19191 arg3 = obj2;
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 (arg1)->_setCallbackInfo(arg2,arg3);
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = SWIG_Py_Void();
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj = 0;
19207 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19208 int res1 = 0 ;
19209 PyObject * obj0 = 0 ;
19210 char * kwnames[] = {
19211 (char *) "provider", NULL
19212 };
19213
19214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19215 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19216 if (!SWIG_IsOK(res1)) {
19217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19218 }
19219 {
19220 PyThreadState* __tstate = wxPyBeginAllowThreads();
19221 wxPyArtProvider::PushProvider(arg1);
19222 wxPyEndAllowThreads(__tstate);
19223 if (PyErr_Occurred()) SWIG_fail;
19224 }
19225 resultobj = SWIG_Py_Void();
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19233 PyObject *resultobj = 0;
19234 bool result;
19235
19236 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (bool)wxPyArtProvider::PopProvider();
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 {
19244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19245 }
19246 return resultobj;
19247 fail:
19248 return NULL;
19249 }
19250
19251
19252 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19253 PyObject *resultobj = 0;
19254 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19255 bool result;
19256 void *argp1 = 0 ;
19257 int res1 = 0 ;
19258 PyObject * obj0 = 0 ;
19259 char * kwnames[] = {
19260 (char *) "provider", NULL
19261 };
19262
19263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19265 if (!SWIG_IsOK(res1)) {
19266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19267 }
19268 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 {
19276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19277 }
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxString *arg1 = 0 ;
19287 wxString const &arg2_defvalue = wxPyART_OTHER ;
19288 wxString *arg2 = (wxString *) &arg2_defvalue ;
19289 wxSize const &arg3_defvalue = wxDefaultSize ;
19290 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19291 wxBitmap result;
19292 bool temp1 = false ;
19293 bool temp2 = false ;
19294 wxSize temp3 ;
19295 PyObject * obj0 = 0 ;
19296 PyObject * obj1 = 0 ;
19297 PyObject * obj2 = 0 ;
19298 char * kwnames[] = {
19299 (char *) "id",(char *) "client",(char *) "size", NULL
19300 };
19301
19302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19303 {
19304 arg1 = wxString_in_helper(obj0);
19305 if (arg1 == NULL) SWIG_fail;
19306 temp1 = true;
19307 }
19308 if (obj1) {
19309 {
19310 arg2 = wxString_in_helper(obj1);
19311 if (arg2 == NULL) SWIG_fail;
19312 temp2 = true;
19313 }
19314 }
19315 if (obj2) {
19316 {
19317 arg3 = &temp3;
19318 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19319 }
19320 }
19321 {
19322 if (!wxPyCheckForApp()) SWIG_fail;
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19329 {
19330 if (temp1)
19331 delete arg1;
19332 }
19333 {
19334 if (temp2)
19335 delete arg2;
19336 }
19337 return resultobj;
19338 fail:
19339 {
19340 if (temp1)
19341 delete arg1;
19342 }
19343 {
19344 if (temp2)
19345 delete arg2;
19346 }
19347 return NULL;
19348 }
19349
19350
19351 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19352 PyObject *resultobj = 0;
19353 wxString *arg1 = 0 ;
19354 wxString const &arg2_defvalue = wxPyART_OTHER ;
19355 wxString *arg2 = (wxString *) &arg2_defvalue ;
19356 wxSize const &arg3_defvalue = wxDefaultSize ;
19357 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19358 wxIcon result;
19359 bool temp1 = false ;
19360 bool temp2 = false ;
19361 wxSize temp3 ;
19362 PyObject * obj0 = 0 ;
19363 PyObject * obj1 = 0 ;
19364 PyObject * obj2 = 0 ;
19365 char * kwnames[] = {
19366 (char *) "id",(char *) "client",(char *) "size", NULL
19367 };
19368
19369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19370 {
19371 arg1 = wxString_in_helper(obj0);
19372 if (arg1 == NULL) SWIG_fail;
19373 temp1 = true;
19374 }
19375 if (obj1) {
19376 {
19377 arg2 = wxString_in_helper(obj1);
19378 if (arg2 == NULL) SWIG_fail;
19379 temp2 = true;
19380 }
19381 }
19382 if (obj2) {
19383 {
19384 arg3 = &temp3;
19385 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19386 }
19387 }
19388 {
19389 if (!wxPyCheckForApp()) SWIG_fail;
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19396 {
19397 if (temp1)
19398 delete arg1;
19399 }
19400 {
19401 if (temp2)
19402 delete arg2;
19403 }
19404 return resultobj;
19405 fail:
19406 {
19407 if (temp1)
19408 delete arg1;
19409 }
19410 {
19411 if (temp2)
19412 delete arg2;
19413 }
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxString *arg1 = 0 ;
19421 bool arg2 = (bool) false ;
19422 wxSize result;
19423 bool temp1 = false ;
19424 bool val2 ;
19425 int ecode2 = 0 ;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char * kwnames[] = {
19429 (char *) "client",(char *) "platform_dependent", NULL
19430 };
19431
19432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19433 {
19434 arg1 = wxString_in_helper(obj0);
19435 if (arg1 == NULL) SWIG_fail;
19436 temp1 = true;
19437 }
19438 if (obj1) {
19439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19440 if (!SWIG_IsOK(ecode2)) {
19441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19442 }
19443 arg2 = static_cast< bool >(val2);
19444 }
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19452 {
19453 if (temp1)
19454 delete arg1;
19455 }
19456 return resultobj;
19457 fail:
19458 {
19459 if (temp1)
19460 delete arg1;
19461 }
19462 return NULL;
19463 }
19464
19465
19466 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19467 PyObject *resultobj = 0;
19468 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19469 void *argp1 = 0 ;
19470 int res1 = 0 ;
19471 PyObject *swig_obj[1] ;
19472
19473 if (!args) SWIG_fail;
19474 swig_obj[0] = args;
19475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19476 if (!SWIG_IsOK(res1)) {
19477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19478 }
19479 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19480 {
19481 PyThreadState* __tstate = wxPyBeginAllowThreads();
19482 wxPyArtProvider_Destroy(arg1);
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 resultobj = SWIG_Py_Void();
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19494 PyObject *obj;
19495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19497 return SWIG_Py_Void();
19498 }
19499
19500 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19501 return SWIG_Python_InitShadowInstance(args);
19502 }
19503
19504 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *resultobj = 0;
19506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19507 void *argp1 = 0 ;
19508 int res1 = 0 ;
19509 PyObject *swig_obj[1] ;
19510
19511 if (!args) SWIG_fail;
19512 swig_obj[0] = args;
19513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19514 if (!SWIG_IsOK(res1)) {
19515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19516 }
19517 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 delete arg1;
19521
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_Py_Void();
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19533 PyObject *resultobj = 0;
19534 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19535 wxConfigBase *result = 0 ;
19536 int res1 = 0 ;
19537 PyObject * obj0 = 0 ;
19538 char * kwnames[] = {
19539 (char *) "config", NULL
19540 };
19541
19542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19543 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19544 if (!SWIG_IsOK(res1)) {
19545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19546 }
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19561 PyObject *resultobj = 0;
19562 bool arg1 = (bool) true ;
19563 wxConfigBase *result = 0 ;
19564 bool val1 ;
19565 int ecode1 = 0 ;
19566 PyObject * obj0 = 0 ;
19567 char * kwnames[] = {
19568 (char *) "createOnDemand", NULL
19569 };
19570
19571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19572 if (obj0) {
19573 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19574 if (!SWIG_IsOK(ecode1)) {
19575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19576 }
19577 arg1 = static_cast< bool >(val1);
19578 }
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19586 return resultobj;
19587 fail:
19588 return NULL;
19589 }
19590
19591
19592 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19593 PyObject *resultobj = 0;
19594 wxConfigBase *result = 0 ;
19595
19596 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = (wxConfigBase *)wxConfigBase::Create();
19600 wxPyEndAllowThreads(__tstate);
19601 if (PyErr_Occurred()) SWIG_fail;
19602 }
19603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19611 PyObject *resultobj = 0;
19612
19613 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19614 {
19615 PyThreadState* __tstate = wxPyBeginAllowThreads();
19616 wxConfigBase::DontCreateOnDemand();
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 resultobj = SWIG_Py_Void();
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj = 0;
19629 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19630 wxString *arg2 = 0 ;
19631 void *argp1 = 0 ;
19632 int res1 = 0 ;
19633 bool temp2 = false ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char * kwnames[] = {
19637 (char *) "self",(char *) "path", NULL
19638 };
19639
19640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19644 }
19645 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19646 {
19647 arg2 = wxString_in_helper(obj1);
19648 if (arg2 == NULL) SWIG_fail;
19649 temp2 = true;
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetPath((wxString const &)*arg2);
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_Py_Void();
19658 {
19659 if (temp2)
19660 delete arg2;
19661 }
19662 return resultobj;
19663 fail:
19664 {
19665 if (temp2)
19666 delete arg2;
19667 }
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19673 PyObject *resultobj = 0;
19674 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19675 wxString *result = 0 ;
19676 void *argp1 = 0 ;
19677 int res1 = 0 ;
19678 PyObject *swig_obj[1] ;
19679
19680 if (!args) SWIG_fail;
19681 swig_obj[0] = args;
19682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19683 if (!SWIG_IsOK(res1)) {
19684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19685 }
19686 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 {
19690 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19691 result = (wxString *) &_result_ref;
19692 }
19693 wxPyEndAllowThreads(__tstate);
19694 if (PyErr_Occurred()) SWIG_fail;
19695 }
19696 {
19697 #if wxUSE_UNICODE
19698 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19699 #else
19700 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19701 #endif
19702 }
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19710 PyObject *resultobj = 0;
19711 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19712 PyObject *result = 0 ;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 PyObject *swig_obj[1] ;
19716
19717 if (!args) SWIG_fail;
19718 swig_obj[0] = args;
19719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19720 if (!SWIG_IsOK(res1)) {
19721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19722 }
19723 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = result;
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19740 long arg2 ;
19741 PyObject *result = 0 ;
19742 void *argp1 = 0 ;
19743 int res1 = 0 ;
19744 long val2 ;
19745 int ecode2 = 0 ;
19746 PyObject * obj0 = 0 ;
19747 PyObject * obj1 = 0 ;
19748 char * kwnames[] = {
19749 (char *) "self",(char *) "index", NULL
19750 };
19751
19752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19754 if (!SWIG_IsOK(res1)) {
19755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19756 }
19757 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19758 ecode2 = SWIG_AsVal_long(obj1, &val2);
19759 if (!SWIG_IsOK(ecode2)) {
19760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19761 }
19762 arg2 = static_cast< long >(val2);
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = result;
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19777 PyObject *resultobj = 0;
19778 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19779 PyObject *result = 0 ;
19780 void *argp1 = 0 ;
19781 int res1 = 0 ;
19782 PyObject *swig_obj[1] ;
19783
19784 if (!args) SWIG_fail;
19785 swig_obj[0] = args;
19786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19787 if (!SWIG_IsOK(res1)) {
19788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19789 }
19790 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19791 {
19792 PyThreadState* __tstate = wxPyBeginAllowThreads();
19793 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19794 wxPyEndAllowThreads(__tstate);
19795 if (PyErr_Occurred()) SWIG_fail;
19796 }
19797 resultobj = result;
19798 return resultobj;
19799 fail:
19800 return NULL;
19801 }
19802
19803
19804 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19805 PyObject *resultobj = 0;
19806 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19807 long arg2 ;
19808 PyObject *result = 0 ;
19809 void *argp1 = 0 ;
19810 int res1 = 0 ;
19811 long val2 ;
19812 int ecode2 = 0 ;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 char * kwnames[] = {
19816 (char *) "self",(char *) "index", NULL
19817 };
19818
19819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19821 if (!SWIG_IsOK(res1)) {
19822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19823 }
19824 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19825 ecode2 = SWIG_AsVal_long(obj1, &val2);
19826 if (!SWIG_IsOK(ecode2)) {
19827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19828 }
19829 arg2 = static_cast< long >(val2);
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 resultobj = result;
19837 return resultobj;
19838 fail:
19839 return NULL;
19840 }
19841
19842
19843 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19844 PyObject *resultobj = 0;
19845 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19846 bool arg2 = (bool) false ;
19847 size_t result;
19848 void *argp1 = 0 ;
19849 int res1 = 0 ;
19850 bool val2 ;
19851 int ecode2 = 0 ;
19852 PyObject * obj0 = 0 ;
19853 PyObject * obj1 = 0 ;
19854 char * kwnames[] = {
19855 (char *) "self",(char *) "recursive", NULL
19856 };
19857
19858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19860 if (!SWIG_IsOK(res1)) {
19861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19862 }
19863 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19864 if (obj1) {
19865 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19866 if (!SWIG_IsOK(ecode2)) {
19867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19868 }
19869 arg2 = static_cast< bool >(val2);
19870 }
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19885 PyObject *resultobj = 0;
19886 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19887 bool arg2 = (bool) false ;
19888 size_t result;
19889 void *argp1 = 0 ;
19890 int res1 = 0 ;
19891 bool val2 ;
19892 int ecode2 = 0 ;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 char * kwnames[] = {
19896 (char *) "self",(char *) "recursive", NULL
19897 };
19898
19899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19901 if (!SWIG_IsOK(res1)) {
19902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19903 }
19904 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19905 if (obj1) {
19906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19907 if (!SWIG_IsOK(ecode2)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19909 }
19910 arg2 = static_cast< bool >(val2);
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19926 PyObject *resultobj = 0;
19927 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19928 wxString *arg2 = 0 ;
19929 bool result;
19930 void *argp1 = 0 ;
19931 int res1 = 0 ;
19932 bool temp2 = false ;
19933 PyObject * obj0 = 0 ;
19934 PyObject * obj1 = 0 ;
19935 char * kwnames[] = {
19936 (char *) "self",(char *) "name", NULL
19937 };
19938
19939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19941 if (!SWIG_IsOK(res1)) {
19942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19943 }
19944 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19945 {
19946 arg2 = wxString_in_helper(obj1);
19947 if (arg2 == NULL) SWIG_fail;
19948 temp2 = true;
19949 }
19950 {
19951 PyThreadState* __tstate = wxPyBeginAllowThreads();
19952 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 {
19957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19958 }
19959 {
19960 if (temp2)
19961 delete arg2;
19962 }
19963 return resultobj;
19964 fail:
19965 {
19966 if (temp2)
19967 delete arg2;
19968 }
19969 return NULL;
19970 }
19971
19972
19973 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj = 0;
19975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19976 wxString *arg2 = 0 ;
19977 bool result;
19978 void *argp1 = 0 ;
19979 int res1 = 0 ;
19980 bool temp2 = false ;
19981 PyObject * obj0 = 0 ;
19982 PyObject * obj1 = 0 ;
19983 char * kwnames[] = {
19984 (char *) "self",(char *) "name", NULL
19985 };
19986
19987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19989 if (!SWIG_IsOK(res1)) {
19990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19991 }
19992 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19993 {
19994 arg2 = wxString_in_helper(obj1);
19995 if (arg2 == NULL) SWIG_fail;
19996 temp2 = true;
19997 }
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 {
20005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20006 }
20007 {
20008 if (temp2)
20009 delete arg2;
20010 }
20011 return resultobj;
20012 fail:
20013 {
20014 if (temp2)
20015 delete arg2;
20016 }
20017 return NULL;
20018 }
20019
20020
20021 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20022 PyObject *resultobj = 0;
20023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20024 wxString *arg2 = 0 ;
20025 bool result;
20026 void *argp1 = 0 ;
20027 int res1 = 0 ;
20028 bool temp2 = false ;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char * kwnames[] = {
20032 (char *) "self",(char *) "name", NULL
20033 };
20034
20035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20039 }
20040 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20041 {
20042 arg2 = wxString_in_helper(obj1);
20043 if (arg2 == NULL) SWIG_fail;
20044 temp2 = true;
20045 }
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 {
20053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20054 }
20055 {
20056 if (temp2)
20057 delete arg2;
20058 }
20059 return resultobj;
20060 fail:
20061 {
20062 if (temp2)
20063 delete arg2;
20064 }
20065 return NULL;
20066 }
20067
20068
20069 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20070 PyObject *resultobj = 0;
20071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20072 wxString *arg2 = 0 ;
20073 wxConfigBase::EntryType result;
20074 void *argp1 = 0 ;
20075 int res1 = 0 ;
20076 bool temp2 = false ;
20077 PyObject * obj0 = 0 ;
20078 PyObject * obj1 = 0 ;
20079 char * kwnames[] = {
20080 (char *) "self",(char *) "name", NULL
20081 };
20082
20083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20085 if (!SWIG_IsOK(res1)) {
20086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20087 }
20088 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20089 {
20090 arg2 = wxString_in_helper(obj1);
20091 if (arg2 == NULL) SWIG_fail;
20092 temp2 = true;
20093 }
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 resultobj = SWIG_From_int(static_cast< int >(result));
20101 {
20102 if (temp2)
20103 delete arg2;
20104 }
20105 return resultobj;
20106 fail:
20107 {
20108 if (temp2)
20109 delete arg2;
20110 }
20111 return NULL;
20112 }
20113
20114
20115 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj = 0;
20117 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20118 wxString *arg2 = 0 ;
20119 wxString const &arg3_defvalue = wxPyEmptyString ;
20120 wxString *arg3 = (wxString *) &arg3_defvalue ;
20121 wxString result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 bool temp2 = false ;
20125 bool temp3 = false ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 PyObject * obj2 = 0 ;
20129 char * kwnames[] = {
20130 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20131 };
20132
20133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20135 if (!SWIG_IsOK(res1)) {
20136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20137 }
20138 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20139 {
20140 arg2 = wxString_in_helper(obj1);
20141 if (arg2 == NULL) SWIG_fail;
20142 temp2 = true;
20143 }
20144 if (obj2) {
20145 {
20146 arg3 = wxString_in_helper(obj2);
20147 if (arg3 == NULL) SWIG_fail;
20148 temp3 = true;
20149 }
20150 }
20151 {
20152 PyThreadState* __tstate = wxPyBeginAllowThreads();
20153 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 {
20158 #if wxUSE_UNICODE
20159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20160 #else
20161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20162 #endif
20163 }
20164 {
20165 if (temp2)
20166 delete arg2;
20167 }
20168 {
20169 if (temp3)
20170 delete arg3;
20171 }
20172 return resultobj;
20173 fail:
20174 {
20175 if (temp2)
20176 delete arg2;
20177 }
20178 {
20179 if (temp3)
20180 delete arg3;
20181 }
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20187 PyObject *resultobj = 0;
20188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20189 wxString *arg2 = 0 ;
20190 long arg3 = (long) 0 ;
20191 long result;
20192 void *argp1 = 0 ;
20193 int res1 = 0 ;
20194 bool temp2 = false ;
20195 long val3 ;
20196 int ecode3 = 0 ;
20197 PyObject * obj0 = 0 ;
20198 PyObject * obj1 = 0 ;
20199 PyObject * obj2 = 0 ;
20200 char * kwnames[] = {
20201 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20202 };
20203
20204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20206 if (!SWIG_IsOK(res1)) {
20207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20208 }
20209 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20210 {
20211 arg2 = wxString_in_helper(obj1);
20212 if (arg2 == NULL) SWIG_fail;
20213 temp2 = true;
20214 }
20215 if (obj2) {
20216 ecode3 = SWIG_AsVal_long(obj2, &val3);
20217 if (!SWIG_IsOK(ecode3)) {
20218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20219 }
20220 arg3 = static_cast< long >(val3);
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 resultobj = SWIG_From_long(static_cast< long >(result));
20229 {
20230 if (temp2)
20231 delete arg2;
20232 }
20233 return resultobj;
20234 fail:
20235 {
20236 if (temp2)
20237 delete arg2;
20238 }
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20244 PyObject *resultobj = 0;
20245 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20246 wxString *arg2 = 0 ;
20247 double arg3 = (double) 0.0 ;
20248 double result;
20249 void *argp1 = 0 ;
20250 int res1 = 0 ;
20251 bool temp2 = false ;
20252 double val3 ;
20253 int ecode3 = 0 ;
20254 PyObject * obj0 = 0 ;
20255 PyObject * obj1 = 0 ;
20256 PyObject * obj2 = 0 ;
20257 char * kwnames[] = {
20258 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20259 };
20260
20261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20265 }
20266 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20267 {
20268 arg2 = wxString_in_helper(obj1);
20269 if (arg2 == NULL) SWIG_fail;
20270 temp2 = true;
20271 }
20272 if (obj2) {
20273 ecode3 = SWIG_AsVal_double(obj2, &val3);
20274 if (!SWIG_IsOK(ecode3)) {
20275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20276 }
20277 arg3 = static_cast< double >(val3);
20278 }
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_From_double(static_cast< double >(result));
20286 {
20287 if (temp2)
20288 delete arg2;
20289 }
20290 return resultobj;
20291 fail:
20292 {
20293 if (temp2)
20294 delete arg2;
20295 }
20296 return NULL;
20297 }
20298
20299
20300 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20301 PyObject *resultobj = 0;
20302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20303 wxString *arg2 = 0 ;
20304 bool arg3 = (bool) false ;
20305 bool result;
20306 void *argp1 = 0 ;
20307 int res1 = 0 ;
20308 bool temp2 = false ;
20309 bool val3 ;
20310 int ecode3 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 PyObject * obj2 = 0 ;
20314 char * kwnames[] = {
20315 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20316 };
20317
20318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20322 }
20323 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20324 {
20325 arg2 = wxString_in_helper(obj1);
20326 if (arg2 == NULL) SWIG_fail;
20327 temp2 = true;
20328 }
20329 if (obj2) {
20330 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20331 if (!SWIG_IsOK(ecode3)) {
20332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20333 }
20334 arg3 = static_cast< bool >(val3);
20335 }
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20344 }
20345 {
20346 if (temp2)
20347 delete arg2;
20348 }
20349 return resultobj;
20350 fail:
20351 {
20352 if (temp2)
20353 delete arg2;
20354 }
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj = 0;
20361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20362 wxString *arg2 = 0 ;
20363 wxString *arg3 = 0 ;
20364 bool result;
20365 void *argp1 = 0 ;
20366 int res1 = 0 ;
20367 bool temp2 = false ;
20368 bool temp3 = false ;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 PyObject * obj2 = 0 ;
20372 char * kwnames[] = {
20373 (char *) "self",(char *) "key",(char *) "value", NULL
20374 };
20375
20376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20378 if (!SWIG_IsOK(res1)) {
20379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20380 }
20381 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20382 {
20383 arg2 = wxString_in_helper(obj1);
20384 if (arg2 == NULL) SWIG_fail;
20385 temp2 = true;
20386 }
20387 {
20388 arg3 = wxString_in_helper(obj2);
20389 if (arg3 == NULL) SWIG_fail;
20390 temp3 = true;
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 {
20399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20400 }
20401 {
20402 if (temp2)
20403 delete arg2;
20404 }
20405 {
20406 if (temp3)
20407 delete arg3;
20408 }
20409 return resultobj;
20410 fail:
20411 {
20412 if (temp2)
20413 delete arg2;
20414 }
20415 {
20416 if (temp3)
20417 delete arg3;
20418 }
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20424 PyObject *resultobj = 0;
20425 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20426 wxString *arg2 = 0 ;
20427 long arg3 ;
20428 bool result;
20429 void *argp1 = 0 ;
20430 int res1 = 0 ;
20431 bool temp2 = false ;
20432 long val3 ;
20433 int ecode3 = 0 ;
20434 PyObject * obj0 = 0 ;
20435 PyObject * obj1 = 0 ;
20436 PyObject * obj2 = 0 ;
20437 char * kwnames[] = {
20438 (char *) "self",(char *) "key",(char *) "value", NULL
20439 };
20440
20441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20443 if (!SWIG_IsOK(res1)) {
20444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20445 }
20446 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20447 {
20448 arg2 = wxString_in_helper(obj1);
20449 if (arg2 == NULL) SWIG_fail;
20450 temp2 = true;
20451 }
20452 ecode3 = SWIG_AsVal_long(obj2, &val3);
20453 if (!SWIG_IsOK(ecode3)) {
20454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20455 }
20456 arg3 = static_cast< long >(val3);
20457 {
20458 PyThreadState* __tstate = wxPyBeginAllowThreads();
20459 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 {
20464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20465 }
20466 {
20467 if (temp2)
20468 delete arg2;
20469 }
20470 return resultobj;
20471 fail:
20472 {
20473 if (temp2)
20474 delete arg2;
20475 }
20476 return NULL;
20477 }
20478
20479
20480 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20481 PyObject *resultobj = 0;
20482 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20483 wxString *arg2 = 0 ;
20484 double arg3 ;
20485 bool result;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 bool temp2 = false ;
20489 double val3 ;
20490 int ecode3 = 0 ;
20491 PyObject * obj0 = 0 ;
20492 PyObject * obj1 = 0 ;
20493 PyObject * obj2 = 0 ;
20494 char * kwnames[] = {
20495 (char *) "self",(char *) "key",(char *) "value", NULL
20496 };
20497
20498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20500 if (!SWIG_IsOK(res1)) {
20501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20502 }
20503 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20504 {
20505 arg2 = wxString_in_helper(obj1);
20506 if (arg2 == NULL) SWIG_fail;
20507 temp2 = true;
20508 }
20509 ecode3 = SWIG_AsVal_double(obj2, &val3);
20510 if (!SWIG_IsOK(ecode3)) {
20511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20512 }
20513 arg3 = static_cast< double >(val3);
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 {
20521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20522 }
20523 {
20524 if (temp2)
20525 delete arg2;
20526 }
20527 return resultobj;
20528 fail:
20529 {
20530 if (temp2)
20531 delete arg2;
20532 }
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj = 0;
20539 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20540 wxString *arg2 = 0 ;
20541 bool arg3 ;
20542 bool result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 bool temp2 = false ;
20546 bool val3 ;
20547 int ecode3 = 0 ;
20548 PyObject * obj0 = 0 ;
20549 PyObject * obj1 = 0 ;
20550 PyObject * obj2 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "self",(char *) "key",(char *) "value", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20559 }
20560 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20561 {
20562 arg2 = wxString_in_helper(obj1);
20563 if (arg2 == NULL) SWIG_fail;
20564 temp2 = true;
20565 }
20566 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20567 if (!SWIG_IsOK(ecode3)) {
20568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20569 }
20570 arg3 = static_cast< bool >(val3);
20571 {
20572 PyThreadState* __tstate = wxPyBeginAllowThreads();
20573 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20574 wxPyEndAllowThreads(__tstate);
20575 if (PyErr_Occurred()) SWIG_fail;
20576 }
20577 {
20578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20579 }
20580 {
20581 if (temp2)
20582 delete arg2;
20583 }
20584 return resultobj;
20585 fail:
20586 {
20587 if (temp2)
20588 delete arg2;
20589 }
20590 return NULL;
20591 }
20592
20593
20594 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20595 PyObject *resultobj = 0;
20596 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20597 bool arg2 = (bool) false ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 bool val2 ;
20602 int ecode2 = 0 ;
20603 PyObject * obj0 = 0 ;
20604 PyObject * obj1 = 0 ;
20605 char * kwnames[] = {
20606 (char *) "self",(char *) "currentOnly", NULL
20607 };
20608
20609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20611 if (!SWIG_IsOK(res1)) {
20612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20613 }
20614 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20615 if (obj1) {
20616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20617 if (!SWIG_IsOK(ecode2)) {
20618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20619 }
20620 arg2 = static_cast< bool >(val2);
20621 }
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (bool)(arg1)->Flush(arg2);
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 {
20629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20630 }
20631 return resultobj;
20632 fail:
20633 return NULL;
20634 }
20635
20636
20637 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20638 PyObject *resultobj = 0;
20639 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20640 wxString *arg2 = 0 ;
20641 wxString *arg3 = 0 ;
20642 bool result;
20643 void *argp1 = 0 ;
20644 int res1 = 0 ;
20645 bool temp2 = false ;
20646 bool temp3 = false ;
20647 PyObject * obj0 = 0 ;
20648 PyObject * obj1 = 0 ;
20649 PyObject * obj2 = 0 ;
20650 char * kwnames[] = {
20651 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20652 };
20653
20654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20656 if (!SWIG_IsOK(res1)) {
20657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20658 }
20659 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20660 {
20661 arg2 = wxString_in_helper(obj1);
20662 if (arg2 == NULL) SWIG_fail;
20663 temp2 = true;
20664 }
20665 {
20666 arg3 = wxString_in_helper(obj2);
20667 if (arg3 == NULL) SWIG_fail;
20668 temp3 = true;
20669 }
20670 {
20671 PyThreadState* __tstate = wxPyBeginAllowThreads();
20672 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20678 }
20679 {
20680 if (temp2)
20681 delete arg2;
20682 }
20683 {
20684 if (temp3)
20685 delete arg3;
20686 }
20687 return resultobj;
20688 fail:
20689 {
20690 if (temp2)
20691 delete arg2;
20692 }
20693 {
20694 if (temp3)
20695 delete arg3;
20696 }
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj = 0;
20703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20704 wxString *arg2 = 0 ;
20705 wxString *arg3 = 0 ;
20706 bool result;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 bool temp2 = false ;
20710 bool temp3 = false ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 PyObject * obj2 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20722 }
20723 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20724 {
20725 arg2 = wxString_in_helper(obj1);
20726 if (arg2 == NULL) SWIG_fail;
20727 temp2 = true;
20728 }
20729 {
20730 arg3 = wxString_in_helper(obj2);
20731 if (arg3 == NULL) SWIG_fail;
20732 temp3 = true;
20733 }
20734 {
20735 PyThreadState* __tstate = wxPyBeginAllowThreads();
20736 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20737 wxPyEndAllowThreads(__tstate);
20738 if (PyErr_Occurred()) SWIG_fail;
20739 }
20740 {
20741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20742 }
20743 {
20744 if (temp2)
20745 delete arg2;
20746 }
20747 {
20748 if (temp3)
20749 delete arg3;
20750 }
20751 return resultobj;
20752 fail:
20753 {
20754 if (temp2)
20755 delete arg2;
20756 }
20757 {
20758 if (temp3)
20759 delete arg3;
20760 }
20761 return NULL;
20762 }
20763
20764
20765 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20766 PyObject *resultobj = 0;
20767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20768 wxString *arg2 = 0 ;
20769 bool arg3 = (bool) true ;
20770 bool result;
20771 void *argp1 = 0 ;
20772 int res1 = 0 ;
20773 bool temp2 = false ;
20774 bool val3 ;
20775 int ecode3 = 0 ;
20776 PyObject * obj0 = 0 ;
20777 PyObject * obj1 = 0 ;
20778 PyObject * obj2 = 0 ;
20779 char * kwnames[] = {
20780 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20781 };
20782
20783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20787 }
20788 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20789 {
20790 arg2 = wxString_in_helper(obj1);
20791 if (arg2 == NULL) SWIG_fail;
20792 temp2 = true;
20793 }
20794 if (obj2) {
20795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20796 if (!SWIG_IsOK(ecode3)) {
20797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20798 }
20799 arg3 = static_cast< bool >(val3);
20800 }
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 {
20811 if (temp2)
20812 delete arg2;
20813 }
20814 return resultobj;
20815 fail:
20816 {
20817 if (temp2)
20818 delete arg2;
20819 }
20820 return NULL;
20821 }
20822
20823
20824 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj = 0;
20826 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20827 wxString *arg2 = 0 ;
20828 bool result;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 bool temp2 = false ;
20832 PyObject * obj0 = 0 ;
20833 PyObject * obj1 = 0 ;
20834 char * kwnames[] = {
20835 (char *) "self",(char *) "key", NULL
20836 };
20837
20838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20840 if (!SWIG_IsOK(res1)) {
20841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20842 }
20843 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20844 {
20845 arg2 = wxString_in_helper(obj1);
20846 if (arg2 == NULL) SWIG_fail;
20847 temp2 = true;
20848 }
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 {
20856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20857 }
20858 {
20859 if (temp2)
20860 delete arg2;
20861 }
20862 return resultobj;
20863 fail:
20864 {
20865 if (temp2)
20866 delete arg2;
20867 }
20868 return NULL;
20869 }
20870
20871
20872 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20873 PyObject *resultobj = 0;
20874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20875 bool result;
20876 void *argp1 = 0 ;
20877 int res1 = 0 ;
20878 PyObject *swig_obj[1] ;
20879
20880 if (!args) SWIG_fail;
20881 swig_obj[0] = args;
20882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20883 if (!SWIG_IsOK(res1)) {
20884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20885 }
20886 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (bool)(arg1)->DeleteAll();
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 {
20894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20895 }
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20903 PyObject *resultobj = 0;
20904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20905 bool arg2 = (bool) true ;
20906 void *argp1 = 0 ;
20907 int res1 = 0 ;
20908 bool val2 ;
20909 int ecode2 = 0 ;
20910 PyObject * obj0 = 0 ;
20911 PyObject * obj1 = 0 ;
20912 char * kwnames[] = {
20913 (char *) "self",(char *) "doIt", NULL
20914 };
20915
20916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20918 if (!SWIG_IsOK(res1)) {
20919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20920 }
20921 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20922 if (obj1) {
20923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20924 if (!SWIG_IsOK(ecode2)) {
20925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20926 }
20927 arg2 = static_cast< bool >(val2);
20928 }
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 (arg1)->SetExpandEnvVars(arg2);
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_Py_Void();
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20945 bool result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20965 }
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20973 PyObject *resultobj = 0;
20974 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20975 bool arg2 = (bool) true ;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 bool val2 ;
20979 int ecode2 = 0 ;
20980 PyObject * obj0 = 0 ;
20981 PyObject * obj1 = 0 ;
20982 char * kwnames[] = {
20983 (char *) "self",(char *) "doIt", NULL
20984 };
20985
20986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20990 }
20991 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20992 if (obj1) {
20993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20994 if (!SWIG_IsOK(ecode2)) {
20995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20996 }
20997 arg2 = static_cast< bool >(val2);
20998 }
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 (arg1)->SetRecordDefaults(arg2);
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 resultobj = SWIG_Py_Void();
21006 return resultobj;
21007 fail:
21008 return NULL;
21009 }
21010
21011
21012 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21013 PyObject *resultobj = 0;
21014 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21015 bool result;
21016 void *argp1 = 0 ;
21017 int res1 = 0 ;
21018 PyObject *swig_obj[1] ;
21019
21020 if (!args) SWIG_fail;
21021 swig_obj[0] = args;
21022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21023 if (!SWIG_IsOK(res1)) {
21024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21025 }
21026 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21027 {
21028 PyThreadState* __tstate = wxPyBeginAllowThreads();
21029 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21030 wxPyEndAllowThreads(__tstate);
21031 if (PyErr_Occurred()) SWIG_fail;
21032 }
21033 {
21034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21035 }
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj = 0;
21044 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21045 wxString *arg2 = 0 ;
21046 wxString result;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 bool temp2 = false ;
21050 PyObject * obj0 = 0 ;
21051 PyObject * obj1 = 0 ;
21052 char * kwnames[] = {
21053 (char *) "self",(char *) "str", NULL
21054 };
21055
21056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21058 if (!SWIG_IsOK(res1)) {
21059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21060 }
21061 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21062 {
21063 arg2 = wxString_in_helper(obj1);
21064 if (arg2 == NULL) SWIG_fail;
21065 temp2 = true;
21066 }
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 #if wxUSE_UNICODE
21075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21076 #else
21077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21078 #endif
21079 }
21080 {
21081 if (temp2)
21082 delete arg2;
21083 }
21084 return resultobj;
21085 fail:
21086 {
21087 if (temp2)
21088 delete arg2;
21089 }
21090 return NULL;
21091 }
21092
21093
21094 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21095 PyObject *resultobj = 0;
21096 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21097 wxString result;
21098 void *argp1 = 0 ;
21099 int res1 = 0 ;
21100 PyObject *swig_obj[1] ;
21101
21102 if (!args) SWIG_fail;
21103 swig_obj[0] = args;
21104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21105 if (!SWIG_IsOK(res1)) {
21106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21107 }
21108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 result = ((wxConfigBase const *)arg1)->GetAppName();
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 {
21116 #if wxUSE_UNICODE
21117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21118 #else
21119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21120 #endif
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21129 PyObject *resultobj = 0;
21130 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21131 wxString result;
21132 void *argp1 = 0 ;
21133 int res1 = 0 ;
21134 PyObject *swig_obj[1] ;
21135
21136 if (!args) SWIG_fail;
21137 swig_obj[0] = args;
21138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21139 if (!SWIG_IsOK(res1)) {
21140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21141 }
21142 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = ((wxConfigBase const *)arg1)->GetVendorName();
21146 wxPyEndAllowThreads(__tstate);
21147 if (PyErr_Occurred()) SWIG_fail;
21148 }
21149 {
21150 #if wxUSE_UNICODE
21151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21152 #else
21153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21154 #endif
21155 }
21156 return resultobj;
21157 fail:
21158 return NULL;
21159 }
21160
21161
21162 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21163 PyObject *resultobj = 0;
21164 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21165 wxString *arg2 = 0 ;
21166 void *argp1 = 0 ;
21167 int res1 = 0 ;
21168 bool temp2 = false ;
21169 PyObject * obj0 = 0 ;
21170 PyObject * obj1 = 0 ;
21171 char * kwnames[] = {
21172 (char *) "self",(char *) "appName", NULL
21173 };
21174
21175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21177 if (!SWIG_IsOK(res1)) {
21178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21179 }
21180 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21181 {
21182 arg2 = wxString_in_helper(obj1);
21183 if (arg2 == NULL) SWIG_fail;
21184 temp2 = true;
21185 }
21186 {
21187 PyThreadState* __tstate = wxPyBeginAllowThreads();
21188 (arg1)->SetAppName((wxString const &)*arg2);
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 resultobj = SWIG_Py_Void();
21193 {
21194 if (temp2)
21195 delete arg2;
21196 }
21197 return resultobj;
21198 fail:
21199 {
21200 if (temp2)
21201 delete arg2;
21202 }
21203 return NULL;
21204 }
21205
21206
21207 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21208 PyObject *resultobj = 0;
21209 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21210 wxString *arg2 = 0 ;
21211 void *argp1 = 0 ;
21212 int res1 = 0 ;
21213 bool temp2 = false ;
21214 PyObject * obj0 = 0 ;
21215 PyObject * obj1 = 0 ;
21216 char * kwnames[] = {
21217 (char *) "self",(char *) "vendorName", NULL
21218 };
21219
21220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21222 if (!SWIG_IsOK(res1)) {
21223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21224 }
21225 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21226 {
21227 arg2 = wxString_in_helper(obj1);
21228 if (arg2 == NULL) SWIG_fail;
21229 temp2 = true;
21230 }
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 (arg1)->SetVendorName((wxString const &)*arg2);
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 resultobj = SWIG_Py_Void();
21238 {
21239 if (temp2)
21240 delete arg2;
21241 }
21242 return resultobj;
21243 fail:
21244 {
21245 if (temp2)
21246 delete arg2;
21247 }
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21253 PyObject *resultobj = 0;
21254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21255 long arg2 ;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 long val2 ;
21259 int ecode2 = 0 ;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 char * kwnames[] = {
21263 (char *) "self",(char *) "style", NULL
21264 };
21265
21266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21268 if (!SWIG_IsOK(res1)) {
21269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21270 }
21271 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21272 ecode2 = SWIG_AsVal_long(obj1, &val2);
21273 if (!SWIG_IsOK(ecode2)) {
21274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21275 }
21276 arg2 = static_cast< long >(val2);
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 (arg1)->SetStyle(arg2);
21280 wxPyEndAllowThreads(__tstate);
21281 if (PyErr_Occurred()) SWIG_fail;
21282 }
21283 resultobj = SWIG_Py_Void();
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21291 PyObject *resultobj = 0;
21292 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21293 long result;
21294 void *argp1 = 0 ;
21295 int res1 = 0 ;
21296 PyObject *swig_obj[1] ;
21297
21298 if (!args) SWIG_fail;
21299 swig_obj[0] = args;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21308 wxPyEndAllowThreads(__tstate);
21309 if (PyErr_Occurred()) SWIG_fail;
21310 }
21311 resultobj = SWIG_From_long(static_cast< long >(result));
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *obj;
21320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21321 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21322 return SWIG_Py_Void();
21323 }
21324
21325 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21326 PyObject *resultobj = 0;
21327 wxString const &arg1_defvalue = wxPyEmptyString ;
21328 wxString *arg1 = (wxString *) &arg1_defvalue ;
21329 wxString const &arg2_defvalue = wxPyEmptyString ;
21330 wxString *arg2 = (wxString *) &arg2_defvalue ;
21331 wxString const &arg3_defvalue = wxPyEmptyString ;
21332 wxString *arg3 = (wxString *) &arg3_defvalue ;
21333 wxString const &arg4_defvalue = wxPyEmptyString ;
21334 wxString *arg4 = (wxString *) &arg4_defvalue ;
21335 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21336 wxConfig *result = 0 ;
21337 bool temp1 = false ;
21338 bool temp2 = false ;
21339 bool temp3 = false ;
21340 bool temp4 = false ;
21341 long val5 ;
21342 int ecode5 = 0 ;
21343 PyObject * obj0 = 0 ;
21344 PyObject * obj1 = 0 ;
21345 PyObject * obj2 = 0 ;
21346 PyObject * obj3 = 0 ;
21347 PyObject * obj4 = 0 ;
21348 char * kwnames[] = {
21349 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21350 };
21351
21352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21353 if (obj0) {
21354 {
21355 arg1 = wxString_in_helper(obj0);
21356 if (arg1 == NULL) SWIG_fail;
21357 temp1 = true;
21358 }
21359 }
21360 if (obj1) {
21361 {
21362 arg2 = wxString_in_helper(obj1);
21363 if (arg2 == NULL) SWIG_fail;
21364 temp2 = true;
21365 }
21366 }
21367 if (obj2) {
21368 {
21369 arg3 = wxString_in_helper(obj2);
21370 if (arg3 == NULL) SWIG_fail;
21371 temp3 = true;
21372 }
21373 }
21374 if (obj3) {
21375 {
21376 arg4 = wxString_in_helper(obj3);
21377 if (arg4 == NULL) SWIG_fail;
21378 temp4 = true;
21379 }
21380 }
21381 if (obj4) {
21382 ecode5 = SWIG_AsVal_long(obj4, &val5);
21383 if (!SWIG_IsOK(ecode5)) {
21384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21385 }
21386 arg5 = static_cast< long >(val5);
21387 }
21388 {
21389 PyThreadState* __tstate = wxPyBeginAllowThreads();
21390 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21395 {
21396 if (temp1)
21397 delete arg1;
21398 }
21399 {
21400 if (temp2)
21401 delete arg2;
21402 }
21403 {
21404 if (temp3)
21405 delete arg3;
21406 }
21407 {
21408 if (temp4)
21409 delete arg4;
21410 }
21411 return resultobj;
21412 fail:
21413 {
21414 if (temp1)
21415 delete arg1;
21416 }
21417 {
21418 if (temp2)
21419 delete arg2;
21420 }
21421 {
21422 if (temp3)
21423 delete arg3;
21424 }
21425 {
21426 if (temp4)
21427 delete arg4;
21428 }
21429 return NULL;
21430 }
21431
21432
21433 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21434 PyObject *resultobj = 0;
21435 wxConfig *arg1 = (wxConfig *) 0 ;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21445 }
21446 arg1 = reinterpret_cast< wxConfig * >(argp1);
21447 {
21448 PyThreadState* __tstate = wxPyBeginAllowThreads();
21449 delete arg1;
21450
21451 wxPyEndAllowThreads(__tstate);
21452 if (PyErr_Occurred()) SWIG_fail;
21453 }
21454 resultobj = SWIG_Py_Void();
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *obj;
21463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21464 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21465 return SWIG_Py_Void();
21466 }
21467
21468 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 return SWIG_Python_InitShadowInstance(args);
21470 }
21471
21472 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj = 0;
21474 wxString const &arg1_defvalue = wxPyEmptyString ;
21475 wxString *arg1 = (wxString *) &arg1_defvalue ;
21476 wxString const &arg2_defvalue = wxPyEmptyString ;
21477 wxString *arg2 = (wxString *) &arg2_defvalue ;
21478 wxString const &arg3_defvalue = wxPyEmptyString ;
21479 wxString *arg3 = (wxString *) &arg3_defvalue ;
21480 wxString const &arg4_defvalue = wxPyEmptyString ;
21481 wxString *arg4 = (wxString *) &arg4_defvalue ;
21482 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21483 wxFileConfig *result = 0 ;
21484 bool temp1 = false ;
21485 bool temp2 = false ;
21486 bool temp3 = false ;
21487 bool temp4 = false ;
21488 long val5 ;
21489 int ecode5 = 0 ;
21490 PyObject * obj0 = 0 ;
21491 PyObject * obj1 = 0 ;
21492 PyObject * obj2 = 0 ;
21493 PyObject * obj3 = 0 ;
21494 PyObject * obj4 = 0 ;
21495 char * kwnames[] = {
21496 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21497 };
21498
21499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21500 if (obj0) {
21501 {
21502 arg1 = wxString_in_helper(obj0);
21503 if (arg1 == NULL) SWIG_fail;
21504 temp1 = true;
21505 }
21506 }
21507 if (obj1) {
21508 {
21509 arg2 = wxString_in_helper(obj1);
21510 if (arg2 == NULL) SWIG_fail;
21511 temp2 = true;
21512 }
21513 }
21514 if (obj2) {
21515 {
21516 arg3 = wxString_in_helper(obj2);
21517 if (arg3 == NULL) SWIG_fail;
21518 temp3 = true;
21519 }
21520 }
21521 if (obj3) {
21522 {
21523 arg4 = wxString_in_helper(obj3);
21524 if (arg4 == NULL) SWIG_fail;
21525 temp4 = true;
21526 }
21527 }
21528 if (obj4) {
21529 ecode5 = SWIG_AsVal_long(obj4, &val5);
21530 if (!SWIG_IsOK(ecode5)) {
21531 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21532 }
21533 arg5 = static_cast< long >(val5);
21534 }
21535 {
21536 PyThreadState* __tstate = wxPyBeginAllowThreads();
21537 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21538 wxPyEndAllowThreads(__tstate);
21539 if (PyErr_Occurred()) SWIG_fail;
21540 }
21541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21542 {
21543 if (temp1)
21544 delete arg1;
21545 }
21546 {
21547 if (temp2)
21548 delete arg2;
21549 }
21550 {
21551 if (temp3)
21552 delete arg3;
21553 }
21554 {
21555 if (temp4)
21556 delete arg4;
21557 }
21558 return resultobj;
21559 fail:
21560 {
21561 if (temp1)
21562 delete arg1;
21563 }
21564 {
21565 if (temp2)
21566 delete arg2;
21567 }
21568 {
21569 if (temp3)
21570 delete arg3;
21571 }
21572 {
21573 if (temp4)
21574 delete arg4;
21575 }
21576 return NULL;
21577 }
21578
21579
21580 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21581 PyObject *resultobj = 0;
21582 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21583 void *argp1 = 0 ;
21584 int res1 = 0 ;
21585 PyObject *swig_obj[1] ;
21586
21587 if (!args) SWIG_fail;
21588 swig_obj[0] = args;
21589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21590 if (!SWIG_IsOK(res1)) {
21591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21592 }
21593 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 delete arg1;
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 resultobj = SWIG_Py_Void();
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21609 PyObject *obj;
21610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21611 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21612 return SWIG_Py_Void();
21613 }
21614
21615 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21616 return SWIG_Python_InitShadowInstance(args);
21617 }
21618
21619 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj = 0;
21621 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21622 wxString *arg2 = 0 ;
21623 wxConfigPathChanger *result = 0 ;
21624 void *argp1 = 0 ;
21625 int res1 = 0 ;
21626 bool temp2 = false ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char * kwnames[] = {
21630 (char *) "config",(char *) "entry", NULL
21631 };
21632
21633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21637 }
21638 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21639 {
21640 arg2 = wxString_in_helper(obj1);
21641 if (arg2 == NULL) SWIG_fail;
21642 temp2 = true;
21643 }
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21651 {
21652 if (temp2)
21653 delete arg2;
21654 }
21655 return resultobj;
21656 fail:
21657 {
21658 if (temp2)
21659 delete arg2;
21660 }
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 PyObject *swig_obj[1] ;
21671
21672 if (!args) SWIG_fail;
21673 swig_obj[0] = args;
21674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21675 if (!SWIG_IsOK(res1)) {
21676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21677 }
21678 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 delete arg1;
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 resultobj = SWIG_Py_Void();
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21694 PyObject *resultobj = 0;
21695 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21696 wxString *result = 0 ;
21697 void *argp1 = 0 ;
21698 int res1 = 0 ;
21699 PyObject *swig_obj[1] ;
21700
21701 if (!args) SWIG_fail;
21702 swig_obj[0] = args;
21703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21704 if (!SWIG_IsOK(res1)) {
21705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21706 }
21707 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 {
21711 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21712 result = (wxString *) &_result_ref;
21713 }
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 {
21718 #if wxUSE_UNICODE
21719 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21720 #else
21721 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21722 #endif
21723 }
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21731 PyObject *obj;
21732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21733 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21734 return SWIG_Py_Void();
21735 }
21736
21737 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21738 return SWIG_Python_InitShadowInstance(args);
21739 }
21740
21741 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj = 0;
21743 wxString *arg1 = 0 ;
21744 wxString result;
21745 bool temp1 = false ;
21746 PyObject * obj0 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "sz", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21752 {
21753 arg1 = wxString_in_helper(obj0);
21754 if (arg1 == NULL) SWIG_fail;
21755 temp1 = true;
21756 }
21757 {
21758 PyThreadState* __tstate = wxPyBeginAllowThreads();
21759 result = wxExpandEnvVars((wxString const &)*arg1);
21760 wxPyEndAllowThreads(__tstate);
21761 if (PyErr_Occurred()) SWIG_fail;
21762 }
21763 {
21764 #if wxUSE_UNICODE
21765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21766 #else
21767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21768 #endif
21769 }
21770 {
21771 if (temp1)
21772 delete arg1;
21773 }
21774 return resultobj;
21775 fail:
21776 {
21777 if (temp1)
21778 delete arg1;
21779 }
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21785 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21786 return 1;
21787 }
21788
21789
21790 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21791 PyObject *pyobj = 0;
21792
21793 {
21794 #if wxUSE_UNICODE
21795 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21796 #else
21797 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21798 #endif
21799 }
21800 return pyobj;
21801 }
21802
21803
21804 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21805 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21806 return 1;
21807 }
21808
21809
21810 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21811 PyObject *pyobj = 0;
21812
21813 {
21814 #if wxUSE_UNICODE
21815 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21816 #else
21817 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21818 #endif
21819 }
21820 return pyobj;
21821 }
21822
21823
21824 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj = 0;
21826 wxDateTime::Country arg1 ;
21827 int val1 ;
21828 int ecode1 = 0 ;
21829 PyObject * obj0 = 0 ;
21830 char * kwnames[] = {
21831 (char *) "country", NULL
21832 };
21833
21834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21835 ecode1 = SWIG_AsVal_int(obj0, &val1);
21836 if (!SWIG_IsOK(ecode1)) {
21837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21838 }
21839 arg1 = static_cast< wxDateTime::Country >(val1);
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 wxDateTime::SetCountry(arg1);
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 resultobj = SWIG_Py_Void();
21847 return resultobj;
21848 fail:
21849 return NULL;
21850 }
21851
21852
21853 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21854 PyObject *resultobj = 0;
21855 wxDateTime::Country result;
21856
21857 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 result = (wxDateTime::Country)wxDateTime::GetCountry();
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 resultobj = SWIG_From_int(static_cast< int >(result));
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21872 PyObject *resultobj = 0;
21873 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21874 bool result;
21875 int val1 ;
21876 int ecode1 = 0 ;
21877 PyObject * obj0 = 0 ;
21878 char * kwnames[] = {
21879 (char *) "country", NULL
21880 };
21881
21882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21883 if (obj0) {
21884 ecode1 = SWIG_AsVal_int(obj0, &val1);
21885 if (!SWIG_IsOK(ecode1)) {
21886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21887 }
21888 arg1 = static_cast< wxDateTime::Country >(val1);
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj = 0;
21907 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21908 int result;
21909 int val1 ;
21910 int ecode1 = 0 ;
21911 PyObject * obj0 = 0 ;
21912 char * kwnames[] = {
21913 (char *) "cal", NULL
21914 };
21915
21916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21917 if (obj0) {
21918 ecode1 = SWIG_AsVal_int(obj0, &val1);
21919 if (!SWIG_IsOK(ecode1)) {
21920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21921 }
21922 arg1 = static_cast< wxDateTime::Calendar >(val1);
21923 }
21924 {
21925 PyThreadState* __tstate = wxPyBeginAllowThreads();
21926 result = (int)wxDateTime::GetCurrentYear(arg1);
21927 wxPyEndAllowThreads(__tstate);
21928 if (PyErr_Occurred()) SWIG_fail;
21929 }
21930 resultobj = SWIG_From_int(static_cast< int >(result));
21931 return resultobj;
21932 fail:
21933 return NULL;
21934 }
21935
21936
21937 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21938 PyObject *resultobj = 0;
21939 int arg1 ;
21940 int result;
21941 int val1 ;
21942 int ecode1 = 0 ;
21943 PyObject * obj0 = 0 ;
21944 char * kwnames[] = {
21945 (char *) "year", NULL
21946 };
21947
21948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21949 ecode1 = SWIG_AsVal_int(obj0, &val1);
21950 if (!SWIG_IsOK(ecode1)) {
21951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21952 }
21953 arg1 = static_cast< int >(val1);
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = (int)wxDateTime::ConvertYearToBC(arg1);
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 resultobj = SWIG_From_int(static_cast< int >(result));
21961 return resultobj;
21962 fail:
21963 return NULL;
21964 }
21965
21966
21967 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = 0;
21969 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21970 wxDateTime::Month result;
21971 int val1 ;
21972 int ecode1 = 0 ;
21973 PyObject * obj0 = 0 ;
21974 char * kwnames[] = {
21975 (char *) "cal", NULL
21976 };
21977
21978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21979 if (obj0) {
21980 ecode1 = SWIG_AsVal_int(obj0, &val1);
21981 if (!SWIG_IsOK(ecode1)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21983 }
21984 arg1 = static_cast< wxDateTime::Calendar >(val1);
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_From_int(static_cast< int >(result));
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj = 0;
22001 int arg1 = (int) wxDateTime::Inv_Year ;
22002 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22003 bool result;
22004 int val1 ;
22005 int ecode1 = 0 ;
22006 int val2 ;
22007 int ecode2 = 0 ;
22008 PyObject * obj0 = 0 ;
22009 PyObject * obj1 = 0 ;
22010 char * kwnames[] = {
22011 (char *) "year",(char *) "cal", NULL
22012 };
22013
22014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22015 if (obj0) {
22016 ecode1 = SWIG_AsVal_int(obj0, &val1);
22017 if (!SWIG_IsOK(ecode1)) {
22018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22019 }
22020 arg1 = static_cast< int >(val1);
22021 }
22022 if (obj1) {
22023 ecode2 = SWIG_AsVal_int(obj1, &val2);
22024 if (!SWIG_IsOK(ecode2)) {
22025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22026 }
22027 arg2 = static_cast< wxDateTime::Calendar >(val2);
22028 }
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22032 wxPyEndAllowThreads(__tstate);
22033 if (PyErr_Occurred()) SWIG_fail;
22034 }
22035 {
22036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22037 }
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj = 0;
22046 int arg1 = (int) wxDateTime::Inv_Year ;
22047 int result;
22048 int val1 ;
22049 int ecode1 = 0 ;
22050 PyObject * obj0 = 0 ;
22051 char * kwnames[] = {
22052 (char *) "year", NULL
22053 };
22054
22055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22056 if (obj0) {
22057 ecode1 = SWIG_AsVal_int(obj0, &val1);
22058 if (!SWIG_IsOK(ecode1)) {
22059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22060 }
22061 arg1 = static_cast< int >(val1);
22062 }
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 result = (int)wxDateTime::GetCentury(arg1);
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 resultobj = SWIG_From_int(static_cast< int >(result));
22070 return resultobj;
22071 fail:
22072 return NULL;
22073 }
22074
22075
22076 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj = 0;
22078 int arg1 ;
22079 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22080 int result;
22081 int val1 ;
22082 int ecode1 = 0 ;
22083 int val2 ;
22084 int ecode2 = 0 ;
22085 PyObject * obj0 = 0 ;
22086 PyObject * obj1 = 0 ;
22087 char * kwnames[] = {
22088 (char *) "year",(char *) "cal", NULL
22089 };
22090
22091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22092 ecode1 = SWIG_AsVal_int(obj0, &val1);
22093 if (!SWIG_IsOK(ecode1)) {
22094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22095 }
22096 arg1 = static_cast< int >(val1);
22097 if (obj1) {
22098 ecode2 = SWIG_AsVal_int(obj1, &val2);
22099 if (!SWIG_IsOK(ecode2)) {
22100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22101 }
22102 arg2 = static_cast< wxDateTime::Calendar >(val2);
22103 }
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 resultobj = SWIG_From_int(static_cast< int >(result));
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj = 0;
22119 wxDateTime::Month arg1 ;
22120 int arg2 = (int) wxDateTime::Inv_Year ;
22121 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22122 int result;
22123 int val1 ;
22124 int ecode1 = 0 ;
22125 int val2 ;
22126 int ecode2 = 0 ;
22127 int val3 ;
22128 int ecode3 = 0 ;
22129 PyObject * obj0 = 0 ;
22130 PyObject * obj1 = 0 ;
22131 PyObject * obj2 = 0 ;
22132 char * kwnames[] = {
22133 (char *) "month",(char *) "year",(char *) "cal", NULL
22134 };
22135
22136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22137 ecode1 = SWIG_AsVal_int(obj0, &val1);
22138 if (!SWIG_IsOK(ecode1)) {
22139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22140 }
22141 arg1 = static_cast< wxDateTime::Month >(val1);
22142 if (obj1) {
22143 ecode2 = SWIG_AsVal_int(obj1, &val2);
22144 if (!SWIG_IsOK(ecode2)) {
22145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22146 }
22147 arg2 = static_cast< int >(val2);
22148 }
22149 if (obj2) {
22150 ecode3 = SWIG_AsVal_int(obj2, &val3);
22151 if (!SWIG_IsOK(ecode3)) {
22152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22153 }
22154 arg3 = static_cast< wxDateTime::Calendar >(val3);
22155 }
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22159 wxPyEndAllowThreads(__tstate);
22160 if (PyErr_Occurred()) SWIG_fail;
22161 }
22162 resultobj = SWIG_From_int(static_cast< int >(result));
22163 return resultobj;
22164 fail:
22165 return NULL;
22166 }
22167
22168
22169 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj = 0;
22171 wxDateTime::Month arg1 ;
22172 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22173 wxString result;
22174 int val1 ;
22175 int ecode1 = 0 ;
22176 int val2 ;
22177 int ecode2 = 0 ;
22178 PyObject * obj0 = 0 ;
22179 PyObject * obj1 = 0 ;
22180 char * kwnames[] = {
22181 (char *) "month",(char *) "flags", NULL
22182 };
22183
22184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22185 ecode1 = SWIG_AsVal_int(obj0, &val1);
22186 if (!SWIG_IsOK(ecode1)) {
22187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22188 }
22189 arg1 = static_cast< wxDateTime::Month >(val1);
22190 if (obj1) {
22191 ecode2 = SWIG_AsVal_int(obj1, &val2);
22192 if (!SWIG_IsOK(ecode2)) {
22193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22194 }
22195 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22196 }
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 result = wxDateTime::GetMonthName(arg1,arg2);
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 {
22204 #if wxUSE_UNICODE
22205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22206 #else
22207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22208 #endif
22209 }
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 wxDateTime::WeekDay arg1 ;
22219 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22220 wxString result;
22221 int val1 ;
22222 int ecode1 = 0 ;
22223 int val2 ;
22224 int ecode2 = 0 ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 char * kwnames[] = {
22228 (char *) "weekday",(char *) "flags", NULL
22229 };
22230
22231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22232 ecode1 = SWIG_AsVal_int(obj0, &val1);
22233 if (!SWIG_IsOK(ecode1)) {
22234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22235 }
22236 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22237 if (obj1) {
22238 ecode2 = SWIG_AsVal_int(obj1, &val2);
22239 if (!SWIG_IsOK(ecode2)) {
22240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22241 }
22242 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22243 }
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 result = wxDateTime::GetWeekDayName(arg1,arg2);
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 {
22251 #if wxUSE_UNICODE
22252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22253 #else
22254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22255 #endif
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22264 PyObject *resultobj = 0;
22265 PyObject *result = 0 ;
22266
22267 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (PyObject *)wxDateTime_GetAmPmStrings();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = result;
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22282 PyObject *resultobj = 0;
22283 int arg1 = (int) wxDateTime::Inv_Year ;
22284 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22285 bool result;
22286 int val1 ;
22287 int ecode1 = 0 ;
22288 int val2 ;
22289 int ecode2 = 0 ;
22290 PyObject * obj0 = 0 ;
22291 PyObject * obj1 = 0 ;
22292 char * kwnames[] = {
22293 (char *) "year",(char *) "country", NULL
22294 };
22295
22296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22297 if (obj0) {
22298 ecode1 = SWIG_AsVal_int(obj0, &val1);
22299 if (!SWIG_IsOK(ecode1)) {
22300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22301 }
22302 arg1 = static_cast< int >(val1);
22303 }
22304 if (obj1) {
22305 ecode2 = SWIG_AsVal_int(obj1, &val2);
22306 if (!SWIG_IsOK(ecode2)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22308 }
22309 arg2 = static_cast< wxDateTime::Country >(val2);
22310 }
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 {
22318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22319 }
22320 return resultobj;
22321 fail:
22322 return NULL;
22323 }
22324
22325
22326 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22327 PyObject *resultobj = 0;
22328 int arg1 = (int) wxDateTime::Inv_Year ;
22329 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22330 wxDateTime result;
22331 int val1 ;
22332 int ecode1 = 0 ;
22333 int val2 ;
22334 int ecode2 = 0 ;
22335 PyObject * obj0 = 0 ;
22336 PyObject * obj1 = 0 ;
22337 char * kwnames[] = {
22338 (char *) "year",(char *) "country", NULL
22339 };
22340
22341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22342 if (obj0) {
22343 ecode1 = SWIG_AsVal_int(obj0, &val1);
22344 if (!SWIG_IsOK(ecode1)) {
22345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22346 }
22347 arg1 = static_cast< int >(val1);
22348 }
22349 if (obj1) {
22350 ecode2 = SWIG_AsVal_int(obj1, &val2);
22351 if (!SWIG_IsOK(ecode2)) {
22352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22353 }
22354 arg2 = static_cast< wxDateTime::Country >(val2);
22355 }
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 result = wxDateTime::GetBeginDST(arg1,arg2);
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj = 0;
22371 int arg1 = (int) wxDateTime::Inv_Year ;
22372 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22373 wxDateTime result;
22374 int val1 ;
22375 int ecode1 = 0 ;
22376 int val2 ;
22377 int ecode2 = 0 ;
22378 PyObject * obj0 = 0 ;
22379 PyObject * obj1 = 0 ;
22380 char * kwnames[] = {
22381 (char *) "year",(char *) "country", NULL
22382 };
22383
22384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22385 if (obj0) {
22386 ecode1 = SWIG_AsVal_int(obj0, &val1);
22387 if (!SWIG_IsOK(ecode1)) {
22388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22389 }
22390 arg1 = static_cast< int >(val1);
22391 }
22392 if (obj1) {
22393 ecode2 = SWIG_AsVal_int(obj1, &val2);
22394 if (!SWIG_IsOK(ecode2)) {
22395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22396 }
22397 arg2 = static_cast< wxDateTime::Country >(val2);
22398 }
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = wxDateTime::GetEndDST(arg1,arg2);
22402 wxPyEndAllowThreads(__tstate);
22403 if (PyErr_Occurred()) SWIG_fail;
22404 }
22405 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22413 PyObject *resultobj = 0;
22414 wxDateTime result;
22415
22416 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = wxDateTime::Now();
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22431 PyObject *resultobj = 0;
22432 wxDateTime result;
22433
22434 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = wxDateTime::UNow();
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22449 PyObject *resultobj = 0;
22450 wxDateTime result;
22451
22452 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 result = wxDateTime::Today();
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22467 PyObject *resultobj = 0;
22468 wxDateTime *result = 0 ;
22469
22470 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 result = (wxDateTime *)new wxDateTime();
22474 wxPyEndAllowThreads(__tstate);
22475 if (PyErr_Occurred()) SWIG_fail;
22476 }
22477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22478 return resultobj;
22479 fail:
22480 return NULL;
22481 }
22482
22483
22484 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22485 PyObject *resultobj = 0;
22486 time_t arg1 ;
22487 wxDateTime *result = 0 ;
22488 unsigned int val1 ;
22489 int ecode1 = 0 ;
22490 PyObject * obj0 = 0 ;
22491 char * kwnames[] = {
22492 (char *) "timet", NULL
22493 };
22494
22495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22496 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22497 if (!SWIG_IsOK(ecode1)) {
22498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22499 }
22500 arg1 = static_cast< time_t >(val1);
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 result = (wxDateTime *)new wxDateTime(arg1);
22504 wxPyEndAllowThreads(__tstate);
22505 if (PyErr_Occurred()) SWIG_fail;
22506 }
22507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj = 0;
22516 double arg1 ;
22517 wxDateTime *result = 0 ;
22518 double val1 ;
22519 int ecode1 = 0 ;
22520 PyObject * obj0 = 0 ;
22521 char * kwnames[] = {
22522 (char *) "jdn", NULL
22523 };
22524
22525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22526 ecode1 = SWIG_AsVal_double(obj0, &val1);
22527 if (!SWIG_IsOK(ecode1)) {
22528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22529 }
22530 arg1 = static_cast< double >(val1);
22531 {
22532 PyThreadState* __tstate = wxPyBeginAllowThreads();
22533 result = (wxDateTime *)new wxDateTime(arg1);
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22545 PyObject *resultobj = 0;
22546 int arg1 ;
22547 int arg2 = (int) 0 ;
22548 int arg3 = (int) 0 ;
22549 int arg4 = (int) 0 ;
22550 wxDateTime *result = 0 ;
22551 int val1 ;
22552 int ecode1 = 0 ;
22553 int val2 ;
22554 int ecode2 = 0 ;
22555 int val3 ;
22556 int ecode3 = 0 ;
22557 int val4 ;
22558 int ecode4 = 0 ;
22559 PyObject * obj0 = 0 ;
22560 PyObject * obj1 = 0 ;
22561 PyObject * obj2 = 0 ;
22562 PyObject * obj3 = 0 ;
22563 char * kwnames[] = {
22564 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22565 };
22566
22567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22568 ecode1 = SWIG_AsVal_int(obj0, &val1);
22569 if (!SWIG_IsOK(ecode1)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22571 }
22572 arg1 = static_cast< int >(val1);
22573 if (obj1) {
22574 ecode2 = SWIG_AsVal_int(obj1, &val2);
22575 if (!SWIG_IsOK(ecode2)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22577 }
22578 arg2 = static_cast< int >(val2);
22579 }
22580 if (obj2) {
22581 ecode3 = SWIG_AsVal_int(obj2, &val3);
22582 if (!SWIG_IsOK(ecode3)) {
22583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22584 }
22585 arg3 = static_cast< int >(val3);
22586 }
22587 if (obj3) {
22588 ecode4 = SWIG_AsVal_int(obj3, &val4);
22589 if (!SWIG_IsOK(ecode4)) {
22590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22591 }
22592 arg4 = static_cast< int >(val4);
22593 }
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22608 PyObject *resultobj = 0;
22609 int arg1 ;
22610 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22611 int arg3 = (int) wxDateTime::Inv_Year ;
22612 int arg4 = (int) 0 ;
22613 int arg5 = (int) 0 ;
22614 int arg6 = (int) 0 ;
22615 int arg7 = (int) 0 ;
22616 wxDateTime *result = 0 ;
22617 int val1 ;
22618 int ecode1 = 0 ;
22619 int val2 ;
22620 int ecode2 = 0 ;
22621 int val3 ;
22622 int ecode3 = 0 ;
22623 int val4 ;
22624 int ecode4 = 0 ;
22625 int val5 ;
22626 int ecode5 = 0 ;
22627 int val6 ;
22628 int ecode6 = 0 ;
22629 int val7 ;
22630 int ecode7 = 0 ;
22631 PyObject * obj0 = 0 ;
22632 PyObject * obj1 = 0 ;
22633 PyObject * obj2 = 0 ;
22634 PyObject * obj3 = 0 ;
22635 PyObject * obj4 = 0 ;
22636 PyObject * obj5 = 0 ;
22637 PyObject * obj6 = 0 ;
22638 char * kwnames[] = {
22639 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22640 };
22641
22642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22643 ecode1 = SWIG_AsVal_int(obj0, &val1);
22644 if (!SWIG_IsOK(ecode1)) {
22645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22646 }
22647 arg1 = static_cast< int >(val1);
22648 if (obj1) {
22649 ecode2 = SWIG_AsVal_int(obj1, &val2);
22650 if (!SWIG_IsOK(ecode2)) {
22651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22652 }
22653 arg2 = static_cast< wxDateTime::Month >(val2);
22654 }
22655 if (obj2) {
22656 ecode3 = SWIG_AsVal_int(obj2, &val3);
22657 if (!SWIG_IsOK(ecode3)) {
22658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22659 }
22660 arg3 = static_cast< int >(val3);
22661 }
22662 if (obj3) {
22663 ecode4 = SWIG_AsVal_int(obj3, &val4);
22664 if (!SWIG_IsOK(ecode4)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22666 }
22667 arg4 = static_cast< int >(val4);
22668 }
22669 if (obj4) {
22670 ecode5 = SWIG_AsVal_int(obj4, &val5);
22671 if (!SWIG_IsOK(ecode5)) {
22672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22673 }
22674 arg5 = static_cast< int >(val5);
22675 }
22676 if (obj5) {
22677 ecode6 = SWIG_AsVal_int(obj5, &val6);
22678 if (!SWIG_IsOK(ecode6)) {
22679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22680 }
22681 arg6 = static_cast< int >(val6);
22682 }
22683 if (obj6) {
22684 ecode7 = SWIG_AsVal_int(obj6, &val7);
22685 if (!SWIG_IsOK(ecode7)) {
22686 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22687 }
22688 arg7 = static_cast< int >(val7);
22689 }
22690 {
22691 PyThreadState* __tstate = wxPyBeginAllowThreads();
22692 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22693 wxPyEndAllowThreads(__tstate);
22694 if (PyErr_Occurred()) SWIG_fail;
22695 }
22696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22704 PyObject *resultobj = 0;
22705 wxDateTime *arg1 = 0 ;
22706 wxDateTime *result = 0 ;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 PyObject * obj0 = 0 ;
22710 char * kwnames[] = {
22711 (char *) "date", NULL
22712 };
22713
22714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22715 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22716 if (!SWIG_IsOK(res1)) {
22717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22718 }
22719 if (!argp1) {
22720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22721 }
22722 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22726 wxPyEndAllowThreads(__tstate);
22727 if (PyErr_Occurred()) SWIG_fail;
22728 }
22729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22730 return resultobj;
22731 fail:
22732 return NULL;
22733 }
22734
22735
22736 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22737 PyObject *resultobj = 0;
22738 wxDateTime *arg1 = (wxDateTime *) 0 ;
22739 void *argp1 = 0 ;
22740 int res1 = 0 ;
22741 PyObject *swig_obj[1] ;
22742
22743 if (!args) SWIG_fail;
22744 swig_obj[0] = args;
22745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22748 }
22749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 delete arg1;
22753
22754 wxPyEndAllowThreads(__tstate);
22755 if (PyErr_Occurred()) SWIG_fail;
22756 }
22757 resultobj = SWIG_Py_Void();
22758 return resultobj;
22759 fail:
22760 return NULL;
22761 }
22762
22763
22764 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22765 PyObject *resultobj = 0;
22766 wxDateTime *arg1 = (wxDateTime *) 0 ;
22767 wxDateTime *result = 0 ;
22768 void *argp1 = 0 ;
22769 int res1 = 0 ;
22770 PyObject *swig_obj[1] ;
22771
22772 if (!args) SWIG_fail;
22773 swig_obj[0] = args;
22774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22775 if (!SWIG_IsOK(res1)) {
22776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22777 }
22778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22779 {
22780 PyThreadState* __tstate = wxPyBeginAllowThreads();
22781 {
22782 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22783 result = (wxDateTime *) &_result_ref;
22784 }
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22796 PyObject *resultobj = 0;
22797 wxDateTime *arg1 = (wxDateTime *) 0 ;
22798 time_t arg2 ;
22799 wxDateTime *result = 0 ;
22800 void *argp1 = 0 ;
22801 int res1 = 0 ;
22802 unsigned int val2 ;
22803 int ecode2 = 0 ;
22804 PyObject * obj0 = 0 ;
22805 PyObject * obj1 = 0 ;
22806 char * kwnames[] = {
22807 (char *) "self",(char *) "timet", NULL
22808 };
22809
22810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22814 }
22815 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22816 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22817 if (!SWIG_IsOK(ecode2)) {
22818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22819 }
22820 arg2 = static_cast< time_t >(val2);
22821 {
22822 PyThreadState* __tstate = wxPyBeginAllowThreads();
22823 {
22824 wxDateTime &_result_ref = (arg1)->Set(arg2);
22825 result = (wxDateTime *) &_result_ref;
22826 }
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22838 PyObject *resultobj = 0;
22839 wxDateTime *arg1 = (wxDateTime *) 0 ;
22840 double arg2 ;
22841 wxDateTime *result = 0 ;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 double val2 ;
22845 int ecode2 = 0 ;
22846 PyObject * obj0 = 0 ;
22847 PyObject * obj1 = 0 ;
22848 char * kwnames[] = {
22849 (char *) "self",(char *) "jdn", NULL
22850 };
22851
22852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22856 }
22857 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22858 ecode2 = SWIG_AsVal_double(obj1, &val2);
22859 if (!SWIG_IsOK(ecode2)) {
22860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22861 }
22862 arg2 = static_cast< double >(val2);
22863 {
22864 PyThreadState* __tstate = wxPyBeginAllowThreads();
22865 {
22866 wxDateTime &_result_ref = (arg1)->Set(arg2);
22867 result = (wxDateTime *) &_result_ref;
22868 }
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22880 PyObject *resultobj = 0;
22881 wxDateTime *arg1 = (wxDateTime *) 0 ;
22882 int arg2 ;
22883 int arg3 = (int) 0 ;
22884 int arg4 = (int) 0 ;
22885 int arg5 = (int) 0 ;
22886 wxDateTime *result = 0 ;
22887 void *argp1 = 0 ;
22888 int res1 = 0 ;
22889 int val2 ;
22890 int ecode2 = 0 ;
22891 int val3 ;
22892 int ecode3 = 0 ;
22893 int val4 ;
22894 int ecode4 = 0 ;
22895 int val5 ;
22896 int ecode5 = 0 ;
22897 PyObject * obj0 = 0 ;
22898 PyObject * obj1 = 0 ;
22899 PyObject * obj2 = 0 ;
22900 PyObject * obj3 = 0 ;
22901 PyObject * obj4 = 0 ;
22902 char * kwnames[] = {
22903 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22904 };
22905
22906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22910 }
22911 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22912 ecode2 = SWIG_AsVal_int(obj1, &val2);
22913 if (!SWIG_IsOK(ecode2)) {
22914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22915 }
22916 arg2 = static_cast< int >(val2);
22917 if (obj2) {
22918 ecode3 = SWIG_AsVal_int(obj2, &val3);
22919 if (!SWIG_IsOK(ecode3)) {
22920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22921 }
22922 arg3 = static_cast< int >(val3);
22923 }
22924 if (obj3) {
22925 ecode4 = SWIG_AsVal_int(obj3, &val4);
22926 if (!SWIG_IsOK(ecode4)) {
22927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22928 }
22929 arg4 = static_cast< int >(val4);
22930 }
22931 if (obj4) {
22932 ecode5 = SWIG_AsVal_int(obj4, &val5);
22933 if (!SWIG_IsOK(ecode5)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22935 }
22936 arg5 = static_cast< int >(val5);
22937 }
22938 {
22939 PyThreadState* __tstate = wxPyBeginAllowThreads();
22940 {
22941 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22942 result = (wxDateTime *) &_result_ref;
22943 }
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22955 PyObject *resultobj = 0;
22956 wxDateTime *arg1 = (wxDateTime *) 0 ;
22957 int arg2 ;
22958 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22959 int arg4 = (int) wxDateTime::Inv_Year ;
22960 int arg5 = (int) 0 ;
22961 int arg6 = (int) 0 ;
22962 int arg7 = (int) 0 ;
22963 int arg8 = (int) 0 ;
22964 wxDateTime *result = 0 ;
22965 void *argp1 = 0 ;
22966 int res1 = 0 ;
22967 int val2 ;
22968 int ecode2 = 0 ;
22969 int val3 ;
22970 int ecode3 = 0 ;
22971 int val4 ;
22972 int ecode4 = 0 ;
22973 int val5 ;
22974 int ecode5 = 0 ;
22975 int val6 ;
22976 int ecode6 = 0 ;
22977 int val7 ;
22978 int ecode7 = 0 ;
22979 int val8 ;
22980 int ecode8 = 0 ;
22981 PyObject * obj0 = 0 ;
22982 PyObject * obj1 = 0 ;
22983 PyObject * obj2 = 0 ;
22984 PyObject * obj3 = 0 ;
22985 PyObject * obj4 = 0 ;
22986 PyObject * obj5 = 0 ;
22987 PyObject * obj6 = 0 ;
22988 PyObject * obj7 = 0 ;
22989 char * kwnames[] = {
22990 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22991 };
22992
22993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22997 }
22998 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22999 ecode2 = SWIG_AsVal_int(obj1, &val2);
23000 if (!SWIG_IsOK(ecode2)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23002 }
23003 arg2 = static_cast< int >(val2);
23004 if (obj2) {
23005 ecode3 = SWIG_AsVal_int(obj2, &val3);
23006 if (!SWIG_IsOK(ecode3)) {
23007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23008 }
23009 arg3 = static_cast< wxDateTime::Month >(val3);
23010 }
23011 if (obj3) {
23012 ecode4 = SWIG_AsVal_int(obj3, &val4);
23013 if (!SWIG_IsOK(ecode4)) {
23014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23015 }
23016 arg4 = static_cast< int >(val4);
23017 }
23018 if (obj4) {
23019 ecode5 = SWIG_AsVal_int(obj4, &val5);
23020 if (!SWIG_IsOK(ecode5)) {
23021 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23022 }
23023 arg5 = static_cast< int >(val5);
23024 }
23025 if (obj5) {
23026 ecode6 = SWIG_AsVal_int(obj5, &val6);
23027 if (!SWIG_IsOK(ecode6)) {
23028 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23029 }
23030 arg6 = static_cast< int >(val6);
23031 }
23032 if (obj6) {
23033 ecode7 = SWIG_AsVal_int(obj6, &val7);
23034 if (!SWIG_IsOK(ecode7)) {
23035 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23036 }
23037 arg7 = static_cast< int >(val7);
23038 }
23039 if (obj7) {
23040 ecode8 = SWIG_AsVal_int(obj7, &val8);
23041 if (!SWIG_IsOK(ecode8)) {
23042 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23043 }
23044 arg8 = static_cast< int >(val8);
23045 }
23046 {
23047 PyThreadState* __tstate = wxPyBeginAllowThreads();
23048 {
23049 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23050 result = (wxDateTime *) &_result_ref;
23051 }
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxDateTime *arg1 = (wxDateTime *) 0 ;
23065 wxDateTime *result = 0 ;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 PyObject *swig_obj[1] ;
23069
23070 if (!args) SWIG_fail;
23071 swig_obj[0] = args;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23075 }
23076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 {
23080 wxDateTime &_result_ref = (arg1)->ResetTime();
23081 result = (wxDateTime *) &_result_ref;
23082 }
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj = 0;
23095 wxDateTime *arg1 = (wxDateTime *) 0 ;
23096 int arg2 ;
23097 wxDateTime *result = 0 ;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 int val2 ;
23101 int ecode2 = 0 ;
23102 PyObject * obj0 = 0 ;
23103 PyObject * obj1 = 0 ;
23104 char * kwnames[] = {
23105 (char *) "self",(char *) "year", NULL
23106 };
23107
23108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23110 if (!SWIG_IsOK(res1)) {
23111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23112 }
23113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23114 ecode2 = SWIG_AsVal_int(obj1, &val2);
23115 if (!SWIG_IsOK(ecode2)) {
23116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23117 }
23118 arg2 = static_cast< int >(val2);
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 {
23122 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23123 result = (wxDateTime *) &_result_ref;
23124 }
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj = 0;
23137 wxDateTime *arg1 = (wxDateTime *) 0 ;
23138 wxDateTime::Month arg2 ;
23139 wxDateTime *result = 0 ;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 int val2 ;
23143 int ecode2 = 0 ;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 char * kwnames[] = {
23147 (char *) "self",(char *) "month", NULL
23148 };
23149
23150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23154 }
23155 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23156 ecode2 = SWIG_AsVal_int(obj1, &val2);
23157 if (!SWIG_IsOK(ecode2)) {
23158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23159 }
23160 arg2 = static_cast< wxDateTime::Month >(val2);
23161 {
23162 PyThreadState* __tstate = wxPyBeginAllowThreads();
23163 {
23164 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23165 result = (wxDateTime *) &_result_ref;
23166 }
23167 wxPyEndAllowThreads(__tstate);
23168 if (PyErr_Occurred()) SWIG_fail;
23169 }
23170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23171 return resultobj;
23172 fail:
23173 return NULL;
23174 }
23175
23176
23177 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23178 PyObject *resultobj = 0;
23179 wxDateTime *arg1 = (wxDateTime *) 0 ;
23180 int arg2 ;
23181 wxDateTime *result = 0 ;
23182 void *argp1 = 0 ;
23183 int res1 = 0 ;
23184 int val2 ;
23185 int ecode2 = 0 ;
23186 PyObject * obj0 = 0 ;
23187 PyObject * obj1 = 0 ;
23188 char * kwnames[] = {
23189 (char *) "self",(char *) "day", NULL
23190 };
23191
23192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23194 if (!SWIG_IsOK(res1)) {
23195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23196 }
23197 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23198 ecode2 = SWIG_AsVal_int(obj1, &val2);
23199 if (!SWIG_IsOK(ecode2)) {
23200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23201 }
23202 arg2 = static_cast< int >(val2);
23203 {
23204 PyThreadState* __tstate = wxPyBeginAllowThreads();
23205 {
23206 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23207 result = (wxDateTime *) &_result_ref;
23208 }
23209 wxPyEndAllowThreads(__tstate);
23210 if (PyErr_Occurred()) SWIG_fail;
23211 }
23212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23213 return resultobj;
23214 fail:
23215 return NULL;
23216 }
23217
23218
23219 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23220 PyObject *resultobj = 0;
23221 wxDateTime *arg1 = (wxDateTime *) 0 ;
23222 int arg2 ;
23223 wxDateTime *result = 0 ;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 int val2 ;
23227 int ecode2 = 0 ;
23228 PyObject * obj0 = 0 ;
23229 PyObject * obj1 = 0 ;
23230 char * kwnames[] = {
23231 (char *) "self",(char *) "hour", NULL
23232 };
23233
23234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23236 if (!SWIG_IsOK(res1)) {
23237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23238 }
23239 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23240 ecode2 = SWIG_AsVal_int(obj1, &val2);
23241 if (!SWIG_IsOK(ecode2)) {
23242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23243 }
23244 arg2 = static_cast< int >(val2);
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 {
23248 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23249 result = (wxDateTime *) &_result_ref;
23250 }
23251 wxPyEndAllowThreads(__tstate);
23252 if (PyErr_Occurred()) SWIG_fail;
23253 }
23254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj = 0;
23263 wxDateTime *arg1 = (wxDateTime *) 0 ;
23264 int arg2 ;
23265 wxDateTime *result = 0 ;
23266 void *argp1 = 0 ;
23267 int res1 = 0 ;
23268 int val2 ;
23269 int ecode2 = 0 ;
23270 PyObject * obj0 = 0 ;
23271 PyObject * obj1 = 0 ;
23272 char * kwnames[] = {
23273 (char *) "self",(char *) "minute", NULL
23274 };
23275
23276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23280 }
23281 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23282 ecode2 = SWIG_AsVal_int(obj1, &val2);
23283 if (!SWIG_IsOK(ecode2)) {
23284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23285 }
23286 arg2 = static_cast< int >(val2);
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 {
23290 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23291 result = (wxDateTime *) &_result_ref;
23292 }
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23304 PyObject *resultobj = 0;
23305 wxDateTime *arg1 = (wxDateTime *) 0 ;
23306 int arg2 ;
23307 wxDateTime *result = 0 ;
23308 void *argp1 = 0 ;
23309 int res1 = 0 ;
23310 int val2 ;
23311 int ecode2 = 0 ;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23314 char * kwnames[] = {
23315 (char *) "self",(char *) "second", NULL
23316 };
23317
23318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23320 if (!SWIG_IsOK(res1)) {
23321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23322 }
23323 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23324 ecode2 = SWIG_AsVal_int(obj1, &val2);
23325 if (!SWIG_IsOK(ecode2)) {
23326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23327 }
23328 arg2 = static_cast< int >(val2);
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 {
23332 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23333 result = (wxDateTime *) &_result_ref;
23334 }
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23339 return resultobj;
23340 fail:
23341 return NULL;
23342 }
23343
23344
23345 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj = 0;
23347 wxDateTime *arg1 = (wxDateTime *) 0 ;
23348 int arg2 ;
23349 wxDateTime *result = 0 ;
23350 void *argp1 = 0 ;
23351 int res1 = 0 ;
23352 int val2 ;
23353 int ecode2 = 0 ;
23354 PyObject * obj0 = 0 ;
23355 PyObject * obj1 = 0 ;
23356 char * kwnames[] = {
23357 (char *) "self",(char *) "millisecond", NULL
23358 };
23359
23360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23364 }
23365 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23366 ecode2 = SWIG_AsVal_int(obj1, &val2);
23367 if (!SWIG_IsOK(ecode2)) {
23368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23369 }
23370 arg2 = static_cast< int >(val2);
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 {
23374 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23375 result = (wxDateTime *) &_result_ref;
23376 }
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23388 PyObject *resultobj = 0;
23389 wxDateTime *arg1 = (wxDateTime *) 0 ;
23390 wxDateTime::WeekDay arg2 ;
23391 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23392 wxDateTime *result = 0 ;
23393 void *argp1 = 0 ;
23394 int res1 = 0 ;
23395 int val2 ;
23396 int ecode2 = 0 ;
23397 int val3 ;
23398 int ecode3 = 0 ;
23399 PyObject * obj0 = 0 ;
23400 PyObject * obj1 = 0 ;
23401 PyObject * obj2 = 0 ;
23402 char * kwnames[] = {
23403 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23404 };
23405
23406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23408 if (!SWIG_IsOK(res1)) {
23409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23410 }
23411 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23412 ecode2 = SWIG_AsVal_int(obj1, &val2);
23413 if (!SWIG_IsOK(ecode2)) {
23414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23415 }
23416 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23417 if (obj2) {
23418 ecode3 = SWIG_AsVal_int(obj2, &val3);
23419 if (!SWIG_IsOK(ecode3)) {
23420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23421 }
23422 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23423 }
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 {
23427 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23428 result = (wxDateTime *) &_result_ref;
23429 }
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23434 return resultobj;
23435 fail:
23436 return NULL;
23437 }
23438
23439
23440 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23441 PyObject *resultobj = 0;
23442 wxDateTime *arg1 = (wxDateTime *) 0 ;
23443 wxDateTime::WeekDay arg2 ;
23444 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23445 wxDateTime result;
23446 void *argp1 = 0 ;
23447 int res1 = 0 ;
23448 int val2 ;
23449 int ecode2 = 0 ;
23450 int val3 ;
23451 int ecode3 = 0 ;
23452 PyObject * obj0 = 0 ;
23453 PyObject * obj1 = 0 ;
23454 PyObject * obj2 = 0 ;
23455 char * kwnames[] = {
23456 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23457 };
23458
23459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23461 if (!SWIG_IsOK(res1)) {
23462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23463 }
23464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23465 ecode2 = SWIG_AsVal_int(obj1, &val2);
23466 if (!SWIG_IsOK(ecode2)) {
23467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23468 }
23469 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23470 if (obj2) {
23471 ecode3 = SWIG_AsVal_int(obj2, &val3);
23472 if (!SWIG_IsOK(ecode3)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23474 }
23475 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23476 }
23477 {
23478 PyThreadState* __tstate = wxPyBeginAllowThreads();
23479 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23480 wxPyEndAllowThreads(__tstate);
23481 if (PyErr_Occurred()) SWIG_fail;
23482 }
23483 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23484 return resultobj;
23485 fail:
23486 return NULL;
23487 }
23488
23489
23490 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23491 PyObject *resultobj = 0;
23492 wxDateTime *arg1 = (wxDateTime *) 0 ;
23493 wxDateTime::WeekDay arg2 ;
23494 wxDateTime *result = 0 ;
23495 void *argp1 = 0 ;
23496 int res1 = 0 ;
23497 int val2 ;
23498 int ecode2 = 0 ;
23499 PyObject * obj0 = 0 ;
23500 PyObject * obj1 = 0 ;
23501 char * kwnames[] = {
23502 (char *) "self",(char *) "weekday", NULL
23503 };
23504
23505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23507 if (!SWIG_IsOK(res1)) {
23508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23509 }
23510 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23511 ecode2 = SWIG_AsVal_int(obj1, &val2);
23512 if (!SWIG_IsOK(ecode2)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23514 }
23515 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 {
23519 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23520 result = (wxDateTime *) &_result_ref;
23521 }
23522 wxPyEndAllowThreads(__tstate);
23523 if (PyErr_Occurred()) SWIG_fail;
23524 }
23525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23533 PyObject *resultobj = 0;
23534 wxDateTime *arg1 = (wxDateTime *) 0 ;
23535 wxDateTime::WeekDay arg2 ;
23536 wxDateTime result;
23537 void *argp1 = 0 ;
23538 int res1 = 0 ;
23539 int val2 ;
23540 int ecode2 = 0 ;
23541 PyObject * obj0 = 0 ;
23542 PyObject * obj1 = 0 ;
23543 char * kwnames[] = {
23544 (char *) "self",(char *) "weekday", NULL
23545 };
23546
23547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23549 if (!SWIG_IsOK(res1)) {
23550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23551 }
23552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23553 ecode2 = SWIG_AsVal_int(obj1, &val2);
23554 if (!SWIG_IsOK(ecode2)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23556 }
23557 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23558 {
23559 PyThreadState* __tstate = wxPyBeginAllowThreads();
23560 result = (arg1)->GetNextWeekDay(arg2);
23561 wxPyEndAllowThreads(__tstate);
23562 if (PyErr_Occurred()) SWIG_fail;
23563 }
23564 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj = 0;
23573 wxDateTime *arg1 = (wxDateTime *) 0 ;
23574 wxDateTime::WeekDay arg2 ;
23575 wxDateTime *result = 0 ;
23576 void *argp1 = 0 ;
23577 int res1 = 0 ;
23578 int val2 ;
23579 int ecode2 = 0 ;
23580 PyObject * obj0 = 0 ;
23581 PyObject * obj1 = 0 ;
23582 char * kwnames[] = {
23583 (char *) "self",(char *) "weekday", NULL
23584 };
23585
23586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23590 }
23591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23592 ecode2 = SWIG_AsVal_int(obj1, &val2);
23593 if (!SWIG_IsOK(ecode2)) {
23594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23595 }
23596 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 {
23600 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23601 result = (wxDateTime *) &_result_ref;
23602 }
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj = 0;
23615 wxDateTime *arg1 = (wxDateTime *) 0 ;
23616 wxDateTime::WeekDay arg2 ;
23617 wxDateTime result;
23618 void *argp1 = 0 ;
23619 int res1 = 0 ;
23620 int val2 ;
23621 int ecode2 = 0 ;
23622 PyObject * obj0 = 0 ;
23623 PyObject * obj1 = 0 ;
23624 char * kwnames[] = {
23625 (char *) "self",(char *) "weekday", NULL
23626 };
23627
23628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23630 if (!SWIG_IsOK(res1)) {
23631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23632 }
23633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23634 ecode2 = SWIG_AsVal_int(obj1, &val2);
23635 if (!SWIG_IsOK(ecode2)) {
23636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23637 }
23638 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (arg1)->GetPrevWeekDay(arg2);
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23646 return resultobj;
23647 fail:
23648 return NULL;
23649 }
23650
23651
23652 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj = 0;
23654 wxDateTime *arg1 = (wxDateTime *) 0 ;
23655 wxDateTime::WeekDay arg2 ;
23656 int arg3 = (int) 1 ;
23657 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23658 int arg5 = (int) wxDateTime::Inv_Year ;
23659 bool result;
23660 void *argp1 = 0 ;
23661 int res1 = 0 ;
23662 int val2 ;
23663 int ecode2 = 0 ;
23664 int val3 ;
23665 int ecode3 = 0 ;
23666 int val4 ;
23667 int ecode4 = 0 ;
23668 int val5 ;
23669 int ecode5 = 0 ;
23670 PyObject * obj0 = 0 ;
23671 PyObject * obj1 = 0 ;
23672 PyObject * obj2 = 0 ;
23673 PyObject * obj3 = 0 ;
23674 PyObject * obj4 = 0 ;
23675 char * kwnames[] = {
23676 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23677 };
23678
23679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23681 if (!SWIG_IsOK(res1)) {
23682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23683 }
23684 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23685 ecode2 = SWIG_AsVal_int(obj1, &val2);
23686 if (!SWIG_IsOK(ecode2)) {
23687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23688 }
23689 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23690 if (obj2) {
23691 ecode3 = SWIG_AsVal_int(obj2, &val3);
23692 if (!SWIG_IsOK(ecode3)) {
23693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23694 }
23695 arg3 = static_cast< int >(val3);
23696 }
23697 if (obj3) {
23698 ecode4 = SWIG_AsVal_int(obj3, &val4);
23699 if (!SWIG_IsOK(ecode4)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23701 }
23702 arg4 = static_cast< wxDateTime::Month >(val4);
23703 }
23704 if (obj4) {
23705 ecode5 = SWIG_AsVal_int(obj4, &val5);
23706 if (!SWIG_IsOK(ecode5)) {
23707 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23708 }
23709 arg5 = static_cast< int >(val5);
23710 }
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 {
23718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23719 }
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 wxDateTime *arg1 = (wxDateTime *) 0 ;
23729 wxDateTime::WeekDay arg2 ;
23730 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23731 int arg4 = (int) wxDateTime::Inv_Year ;
23732 bool result;
23733 void *argp1 = 0 ;
23734 int res1 = 0 ;
23735 int val2 ;
23736 int ecode2 = 0 ;
23737 int val3 ;
23738 int ecode3 = 0 ;
23739 int val4 ;
23740 int ecode4 = 0 ;
23741 PyObject * obj0 = 0 ;
23742 PyObject * obj1 = 0 ;
23743 PyObject * obj2 = 0 ;
23744 PyObject * obj3 = 0 ;
23745 char * kwnames[] = {
23746 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23747 };
23748
23749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23753 }
23754 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23755 ecode2 = SWIG_AsVal_int(obj1, &val2);
23756 if (!SWIG_IsOK(ecode2)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23758 }
23759 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23760 if (obj2) {
23761 ecode3 = SWIG_AsVal_int(obj2, &val3);
23762 if (!SWIG_IsOK(ecode3)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23764 }
23765 arg3 = static_cast< wxDateTime::Month >(val3);
23766 }
23767 if (obj3) {
23768 ecode4 = SWIG_AsVal_int(obj3, &val4);
23769 if (!SWIG_IsOK(ecode4)) {
23770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23771 }
23772 arg4 = static_cast< int >(val4);
23773 }
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 {
23781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23782 }
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23790 PyObject *resultobj = 0;
23791 wxDateTime *arg1 = (wxDateTime *) 0 ;
23792 wxDateTime::WeekDay arg2 ;
23793 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23794 int arg4 = (int) wxDateTime::Inv_Year ;
23795 wxDateTime result;
23796 void *argp1 = 0 ;
23797 int res1 = 0 ;
23798 int val2 ;
23799 int ecode2 = 0 ;
23800 int val3 ;
23801 int ecode3 = 0 ;
23802 int val4 ;
23803 int ecode4 = 0 ;
23804 PyObject * obj0 = 0 ;
23805 PyObject * obj1 = 0 ;
23806 PyObject * obj2 = 0 ;
23807 PyObject * obj3 = 0 ;
23808 char * kwnames[] = {
23809 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23810 };
23811
23812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23814 if (!SWIG_IsOK(res1)) {
23815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23816 }
23817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23818 ecode2 = SWIG_AsVal_int(obj1, &val2);
23819 if (!SWIG_IsOK(ecode2)) {
23820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23821 }
23822 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23823 if (obj2) {
23824 ecode3 = SWIG_AsVal_int(obj2, &val3);
23825 if (!SWIG_IsOK(ecode3)) {
23826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23827 }
23828 arg3 = static_cast< wxDateTime::Month >(val3);
23829 }
23830 if (obj3) {
23831 ecode4 = SWIG_AsVal_int(obj3, &val4);
23832 if (!SWIG_IsOK(ecode4)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23834 }
23835 arg4 = static_cast< int >(val4);
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23851 PyObject *resultobj = 0;
23852 wxDateTime *arg1 = (wxDateTime *) 0 ;
23853 int arg2 ;
23854 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23855 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23856 bool result;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 int val2 ;
23860 int ecode2 = 0 ;
23861 int val3 ;
23862 int ecode3 = 0 ;
23863 int val4 ;
23864 int ecode4 = 0 ;
23865 PyObject * obj0 = 0 ;
23866 PyObject * obj1 = 0 ;
23867 PyObject * obj2 = 0 ;
23868 PyObject * obj3 = 0 ;
23869 char * kwnames[] = {
23870 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23871 };
23872
23873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23875 if (!SWIG_IsOK(res1)) {
23876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23877 }
23878 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23879 ecode2 = SWIG_AsVal_int(obj1, &val2);
23880 if (!SWIG_IsOK(ecode2)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23882 }
23883 arg2 = static_cast< int >(val2);
23884 if (obj2) {
23885 ecode3 = SWIG_AsVal_int(obj2, &val3);
23886 if (!SWIG_IsOK(ecode3)) {
23887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23888 }
23889 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23890 }
23891 if (obj3) {
23892 ecode4 = SWIG_AsVal_int(obj3, &val4);
23893 if (!SWIG_IsOK(ecode4)) {
23894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23895 }
23896 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23897 }
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj = 0;
23915 wxDateTime *arg1 = (wxDateTime *) 0 ;
23916 int arg2 ;
23917 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23918 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23919 wxDateTime result;
23920 void *argp1 = 0 ;
23921 int res1 = 0 ;
23922 int val2 ;
23923 int ecode2 = 0 ;
23924 int val3 ;
23925 int ecode3 = 0 ;
23926 int val4 ;
23927 int ecode4 = 0 ;
23928 PyObject * obj0 = 0 ;
23929 PyObject * obj1 = 0 ;
23930 PyObject * obj2 = 0 ;
23931 PyObject * obj3 = 0 ;
23932 char * kwnames[] = {
23933 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23934 };
23935
23936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23938 if (!SWIG_IsOK(res1)) {
23939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23940 }
23941 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23942 ecode2 = SWIG_AsVal_int(obj1, &val2);
23943 if (!SWIG_IsOK(ecode2)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23945 }
23946 arg2 = static_cast< int >(val2);
23947 if (obj2) {
23948 ecode3 = SWIG_AsVal_int(obj2, &val3);
23949 if (!SWIG_IsOK(ecode3)) {
23950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23951 }
23952 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23953 }
23954 if (obj3) {
23955 ecode4 = SWIG_AsVal_int(obj3, &val4);
23956 if (!SWIG_IsOK(ecode4)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23958 }
23959 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23960 }
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (arg1)->GetWeek(arg2,arg3,arg4);
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23975 PyObject *resultobj = 0;
23976 int arg1 ;
23977 int arg2 ;
23978 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23979 wxDateTime result;
23980 int val1 ;
23981 int ecode1 = 0 ;
23982 int val2 ;
23983 int ecode2 = 0 ;
23984 int val3 ;
23985 int ecode3 = 0 ;
23986 PyObject * obj0 = 0 ;
23987 PyObject * obj1 = 0 ;
23988 PyObject * obj2 = 0 ;
23989 char * kwnames[] = {
23990 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23991 };
23992
23993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23994 ecode1 = SWIG_AsVal_int(obj0, &val1);
23995 if (!SWIG_IsOK(ecode1)) {
23996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23997 }
23998 arg1 = static_cast< int >(val1);
23999 ecode2 = SWIG_AsVal_int(obj1, &val2);
24000 if (!SWIG_IsOK(ecode2)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24002 }
24003 arg2 = static_cast< int >(val2);
24004 if (obj2) {
24005 ecode3 = SWIG_AsVal_int(obj2, &val3);
24006 if (!SWIG_IsOK(ecode3)) {
24007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24008 }
24009 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24010 }
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24018 return resultobj;
24019 fail:
24020 return NULL;
24021 }
24022
24023
24024 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj = 0;
24026 wxDateTime *arg1 = (wxDateTime *) 0 ;
24027 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24028 int arg3 = (int) wxDateTime::Inv_Year ;
24029 wxDateTime *result = 0 ;
24030 void *argp1 = 0 ;
24031 int res1 = 0 ;
24032 int val2 ;
24033 int ecode2 = 0 ;
24034 int val3 ;
24035 int ecode3 = 0 ;
24036 PyObject * obj0 = 0 ;
24037 PyObject * obj1 = 0 ;
24038 PyObject * obj2 = 0 ;
24039 char * kwnames[] = {
24040 (char *) "self",(char *) "month",(char *) "year", NULL
24041 };
24042
24043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24045 if (!SWIG_IsOK(res1)) {
24046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24047 }
24048 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24049 if (obj1) {
24050 ecode2 = SWIG_AsVal_int(obj1, &val2);
24051 if (!SWIG_IsOK(ecode2)) {
24052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24053 }
24054 arg2 = static_cast< wxDateTime::Month >(val2);
24055 }
24056 if (obj2) {
24057 ecode3 = SWIG_AsVal_int(obj2, &val3);
24058 if (!SWIG_IsOK(ecode3)) {
24059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24060 }
24061 arg3 = static_cast< int >(val3);
24062 }
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 {
24066 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24067 result = (wxDateTime *) &_result_ref;
24068 }
24069 wxPyEndAllowThreads(__tstate);
24070 if (PyErr_Occurred()) SWIG_fail;
24071 }
24072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24080 PyObject *resultobj = 0;
24081 wxDateTime *arg1 = (wxDateTime *) 0 ;
24082 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24083 int arg3 = (int) wxDateTime::Inv_Year ;
24084 wxDateTime result;
24085 void *argp1 = 0 ;
24086 int res1 = 0 ;
24087 int val2 ;
24088 int ecode2 = 0 ;
24089 int val3 ;
24090 int ecode3 = 0 ;
24091 PyObject * obj0 = 0 ;
24092 PyObject * obj1 = 0 ;
24093 PyObject * obj2 = 0 ;
24094 char * kwnames[] = {
24095 (char *) "self",(char *) "month",(char *) "year", NULL
24096 };
24097
24098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24100 if (!SWIG_IsOK(res1)) {
24101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24102 }
24103 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24104 if (obj1) {
24105 ecode2 = SWIG_AsVal_int(obj1, &val2);
24106 if (!SWIG_IsOK(ecode2)) {
24107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24108 }
24109 arg2 = static_cast< wxDateTime::Month >(val2);
24110 }
24111 if (obj2) {
24112 ecode3 = SWIG_AsVal_int(obj2, &val3);
24113 if (!SWIG_IsOK(ecode3)) {
24114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24115 }
24116 arg3 = static_cast< int >(val3);
24117 }
24118 {
24119 PyThreadState* __tstate = wxPyBeginAllowThreads();
24120 result = (arg1)->GetLastMonthDay(arg2,arg3);
24121 wxPyEndAllowThreads(__tstate);
24122 if (PyErr_Occurred()) SWIG_fail;
24123 }
24124 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24125 return resultobj;
24126 fail:
24127 return NULL;
24128 }
24129
24130
24131 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj = 0;
24133 wxDateTime *arg1 = (wxDateTime *) 0 ;
24134 int arg2 ;
24135 wxDateTime *result = 0 ;
24136 void *argp1 = 0 ;
24137 int res1 = 0 ;
24138 int val2 ;
24139 int ecode2 = 0 ;
24140 PyObject * obj0 = 0 ;
24141 PyObject * obj1 = 0 ;
24142 char * kwnames[] = {
24143 (char *) "self",(char *) "yday", NULL
24144 };
24145
24146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24148 if (!SWIG_IsOK(res1)) {
24149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24150 }
24151 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24152 ecode2 = SWIG_AsVal_int(obj1, &val2);
24153 if (!SWIG_IsOK(ecode2)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24155 }
24156 arg2 = static_cast< int >(val2);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 {
24160 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24161 result = (wxDateTime *) &_result_ref;
24162 }
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24174 PyObject *resultobj = 0;
24175 wxDateTime *arg1 = (wxDateTime *) 0 ;
24176 int arg2 ;
24177 wxDateTime result;
24178 void *argp1 = 0 ;
24179 int res1 = 0 ;
24180 int val2 ;
24181 int ecode2 = 0 ;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 char * kwnames[] = {
24185 (char *) "self",(char *) "yday", NULL
24186 };
24187
24188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24190 if (!SWIG_IsOK(res1)) {
24191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24192 }
24193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24194 ecode2 = SWIG_AsVal_int(obj1, &val2);
24195 if (!SWIG_IsOK(ecode2)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24197 }
24198 arg2 = static_cast< int >(val2);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = (arg1)->GetYearDay(arg2);
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24213 PyObject *resultobj = 0;
24214 wxDateTime *arg1 = (wxDateTime *) 0 ;
24215 double result;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 PyObject *swig_obj[1] ;
24219
24220 if (!args) SWIG_fail;
24221 swig_obj[0] = args;
24222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24225 }
24226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24227 {
24228 PyThreadState* __tstate = wxPyBeginAllowThreads();
24229 result = (double)(arg1)->GetJulianDayNumber();
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 resultobj = SWIG_From_double(static_cast< double >(result));
24234 return resultobj;
24235 fail:
24236 return NULL;
24237 }
24238
24239
24240 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24241 PyObject *resultobj = 0;
24242 wxDateTime *arg1 = (wxDateTime *) 0 ;
24243 double result;
24244 void *argp1 = 0 ;
24245 int res1 = 0 ;
24246 PyObject *swig_obj[1] ;
24247
24248 if (!args) SWIG_fail;
24249 swig_obj[0] = args;
24250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24251 if (!SWIG_IsOK(res1)) {
24252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24253 }
24254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 result = (double)(arg1)->GetJDN();
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 resultobj = SWIG_From_double(static_cast< double >(result));
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24269 PyObject *resultobj = 0;
24270 wxDateTime *arg1 = (wxDateTime *) 0 ;
24271 double result;
24272 void *argp1 = 0 ;
24273 int res1 = 0 ;
24274 PyObject *swig_obj[1] ;
24275
24276 if (!args) SWIG_fail;
24277 swig_obj[0] = args;
24278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24279 if (!SWIG_IsOK(res1)) {
24280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24281 }
24282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24283 {
24284 PyThreadState* __tstate = wxPyBeginAllowThreads();
24285 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_From_double(static_cast< double >(result));
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24297 PyObject *resultobj = 0;
24298 wxDateTime *arg1 = (wxDateTime *) 0 ;
24299 double result;
24300 void *argp1 = 0 ;
24301 int res1 = 0 ;
24302 PyObject *swig_obj[1] ;
24303
24304 if (!args) SWIG_fail;
24305 swig_obj[0] = args;
24306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24307 if (!SWIG_IsOK(res1)) {
24308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24309 }
24310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24311 {
24312 PyThreadState* __tstate = wxPyBeginAllowThreads();
24313 result = (double)(arg1)->GetMJD();
24314 wxPyEndAllowThreads(__tstate);
24315 if (PyErr_Occurred()) SWIG_fail;
24316 }
24317 resultobj = SWIG_From_double(static_cast< double >(result));
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxDateTime *arg1 = (wxDateTime *) 0 ;
24327 double result;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 PyObject *swig_obj[1] ;
24331
24332 if (!args) SWIG_fail;
24333 swig_obj[0] = args;
24334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24337 }
24338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = (double)(arg1)->GetRataDie();
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 resultobj = SWIG_From_double(static_cast< double >(result));
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj = 0;
24354 wxDateTime *arg1 = (wxDateTime *) 0 ;
24355 wxDateTime::TimeZone *arg2 = 0 ;
24356 bool arg3 = (bool) false ;
24357 wxDateTime result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 bool temp2 = false ;
24361 bool val3 ;
24362 int ecode3 = 0 ;
24363 PyObject * obj0 = 0 ;
24364 PyObject * obj1 = 0 ;
24365 PyObject * obj2 = 0 ;
24366 char * kwnames[] = {
24367 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24368 };
24369
24370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24372 if (!SWIG_IsOK(res1)) {
24373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24374 }
24375 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24376 {
24377 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24378 temp2 = true;
24379 }
24380 if (obj2) {
24381 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24382 if (!SWIG_IsOK(ecode3)) {
24383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24384 }
24385 arg3 = static_cast< bool >(val3);
24386 }
24387 {
24388 PyThreadState* __tstate = wxPyBeginAllowThreads();
24389 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24394 {
24395 if (temp2) delete arg2;
24396 }
24397 return resultobj;
24398 fail:
24399 {
24400 if (temp2) delete arg2;
24401 }
24402 return NULL;
24403 }
24404
24405
24406 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj = 0;
24408 wxDateTime *arg1 = (wxDateTime *) 0 ;
24409 wxDateTime::TimeZone *arg2 = 0 ;
24410 bool arg3 = (bool) false ;
24411 wxDateTime *result = 0 ;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 bool temp2 = false ;
24415 bool val3 ;
24416 int ecode3 = 0 ;
24417 PyObject * obj0 = 0 ;
24418 PyObject * obj1 = 0 ;
24419 PyObject * obj2 = 0 ;
24420 char * kwnames[] = {
24421 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24422 };
24423
24424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24426 if (!SWIG_IsOK(res1)) {
24427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24428 }
24429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24430 {
24431 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24432 temp2 = true;
24433 }
24434 if (obj2) {
24435 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24436 if (!SWIG_IsOK(ecode3)) {
24437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24438 }
24439 arg3 = static_cast< bool >(val3);
24440 }
24441 {
24442 PyThreadState* __tstate = wxPyBeginAllowThreads();
24443 {
24444 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24445 result = (wxDateTime *) &_result_ref;
24446 }
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24451 {
24452 if (temp2) delete arg2;
24453 }
24454 return resultobj;
24455 fail:
24456 {
24457 if (temp2) delete arg2;
24458 }
24459 return NULL;
24460 }
24461
24462
24463 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj = 0;
24465 wxDateTime *arg1 = (wxDateTime *) 0 ;
24466 wxDateTime::TimeZone *arg2 = 0 ;
24467 bool arg3 = (bool) false ;
24468 wxDateTime result;
24469 void *argp1 = 0 ;
24470 int res1 = 0 ;
24471 bool temp2 = false ;
24472 bool val3 ;
24473 int ecode3 = 0 ;
24474 PyObject * obj0 = 0 ;
24475 PyObject * obj1 = 0 ;
24476 PyObject * obj2 = 0 ;
24477 char * kwnames[] = {
24478 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24479 };
24480
24481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24483 if (!SWIG_IsOK(res1)) {
24484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24485 }
24486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24487 {
24488 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24489 temp2 = true;
24490 }
24491 if (obj2) {
24492 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24493 if (!SWIG_IsOK(ecode3)) {
24494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24495 }
24496 arg3 = static_cast< bool >(val3);
24497 }
24498 {
24499 PyThreadState* __tstate = wxPyBeginAllowThreads();
24500 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24505 {
24506 if (temp2) delete arg2;
24507 }
24508 return resultobj;
24509 fail:
24510 {
24511 if (temp2) delete arg2;
24512 }
24513 return NULL;
24514 }
24515
24516
24517 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24518 PyObject *resultobj = 0;
24519 wxDateTime *arg1 = (wxDateTime *) 0 ;
24520 wxDateTime::TimeZone *arg2 = 0 ;
24521 bool arg3 = (bool) false ;
24522 wxDateTime *result = 0 ;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 bool temp2 = false ;
24526 bool val3 ;
24527 int ecode3 = 0 ;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 PyObject * obj2 = 0 ;
24531 char * kwnames[] = {
24532 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24533 };
24534
24535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24537 if (!SWIG_IsOK(res1)) {
24538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24539 }
24540 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24541 {
24542 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24543 temp2 = true;
24544 }
24545 if (obj2) {
24546 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24547 if (!SWIG_IsOK(ecode3)) {
24548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24549 }
24550 arg3 = static_cast< bool >(val3);
24551 }
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 {
24555 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24556 result = (wxDateTime *) &_result_ref;
24557 }
24558 wxPyEndAllowThreads(__tstate);
24559 if (PyErr_Occurred()) SWIG_fail;
24560 }
24561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 {
24563 if (temp2) delete arg2;
24564 }
24565 return resultobj;
24566 fail:
24567 {
24568 if (temp2) delete arg2;
24569 }
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj = 0;
24576 wxDateTime *arg1 = (wxDateTime *) 0 ;
24577 bool arg2 = (bool) false ;
24578 wxDateTime result;
24579 void *argp1 = 0 ;
24580 int res1 = 0 ;
24581 bool val2 ;
24582 int ecode2 = 0 ;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char * kwnames[] = {
24586 (char *) "self",(char *) "noDST", NULL
24587 };
24588
24589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24593 }
24594 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24595 if (obj1) {
24596 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24597 if (!SWIG_IsOK(ecode2)) {
24598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24599 }
24600 arg2 = static_cast< bool >(val2);
24601 }
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 wxDateTime *arg1 = (wxDateTime *) 0 ;
24618 bool arg2 = (bool) false ;
24619 wxDateTime *result = 0 ;
24620 void *argp1 = 0 ;
24621 int res1 = 0 ;
24622 bool val2 ;
24623 int ecode2 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char * kwnames[] = {
24627 (char *) "self",(char *) "noDST", NULL
24628 };
24629
24630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24632 if (!SWIG_IsOK(res1)) {
24633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24634 }
24635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24636 if (obj1) {
24637 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24638 if (!SWIG_IsOK(ecode2)) {
24639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24640 }
24641 arg2 = static_cast< bool >(val2);
24642 }
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 {
24646 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24647 result = (wxDateTime *) &_result_ref;
24648 }
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24653 return resultobj;
24654 fail:
24655 return NULL;
24656 }
24657
24658
24659 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24660 PyObject *resultobj = 0;
24661 wxDateTime *arg1 = (wxDateTime *) 0 ;
24662 bool arg2 = (bool) false ;
24663 wxDateTime result;
24664 void *argp1 = 0 ;
24665 int res1 = 0 ;
24666 bool val2 ;
24667 int ecode2 = 0 ;
24668 PyObject * obj0 = 0 ;
24669 PyObject * obj1 = 0 ;
24670 char * kwnames[] = {
24671 (char *) "self",(char *) "noDST", NULL
24672 };
24673
24674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24676 if (!SWIG_IsOK(res1)) {
24677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24678 }
24679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24680 if (obj1) {
24681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24682 if (!SWIG_IsOK(ecode2)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24684 }
24685 arg2 = static_cast< bool >(val2);
24686 }
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj = 0;
24702 wxDateTime *arg1 = (wxDateTime *) 0 ;
24703 bool arg2 = (bool) false ;
24704 wxDateTime *result = 0 ;
24705 void *argp1 = 0 ;
24706 int res1 = 0 ;
24707 bool val2 ;
24708 int ecode2 = 0 ;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 char * kwnames[] = {
24712 (char *) "self",(char *) "noDST", NULL
24713 };
24714
24715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24717 if (!SWIG_IsOK(res1)) {
24718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24719 }
24720 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24721 if (obj1) {
24722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24723 if (!SWIG_IsOK(ecode2)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24725 }
24726 arg2 = static_cast< bool >(val2);
24727 }
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 {
24731 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24732 result = (wxDateTime *) &_result_ref;
24733 }
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj = 0;
24746 wxDateTime *arg1 = (wxDateTime *) 0 ;
24747 bool arg2 = (bool) false ;
24748 wxDateTime result;
24749 void *argp1 = 0 ;
24750 int res1 = 0 ;
24751 bool val2 ;
24752 int ecode2 = 0 ;
24753 PyObject * obj0 = 0 ;
24754 PyObject * obj1 = 0 ;
24755 char * kwnames[] = {
24756 (char *) "self",(char *) "noDST", NULL
24757 };
24758
24759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24761 if (!SWIG_IsOK(res1)) {
24762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24763 }
24764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24765 if (obj1) {
24766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24767 if (!SWIG_IsOK(ecode2)) {
24768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24769 }
24770 arg2 = static_cast< bool >(val2);
24771 }
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24786 PyObject *resultobj = 0;
24787 wxDateTime *arg1 = (wxDateTime *) 0 ;
24788 bool arg2 = (bool) false ;
24789 wxDateTime *result = 0 ;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 bool val2 ;
24793 int ecode2 = 0 ;
24794 PyObject * obj0 = 0 ;
24795 PyObject * obj1 = 0 ;
24796 char * kwnames[] = {
24797 (char *) "self",(char *) "noDST", NULL
24798 };
24799
24800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24802 if (!SWIG_IsOK(res1)) {
24803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24804 }
24805 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24806 if (obj1) {
24807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24808 if (!SWIG_IsOK(ecode2)) {
24809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24810 }
24811 arg2 = static_cast< bool >(val2);
24812 }
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 {
24816 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24817 result = (wxDateTime *) &_result_ref;
24818 }
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj = 0;
24831 wxDateTime *arg1 = (wxDateTime *) 0 ;
24832 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24833 int result;
24834 void *argp1 = 0 ;
24835 int res1 = 0 ;
24836 int val2 ;
24837 int ecode2 = 0 ;
24838 PyObject * obj0 = 0 ;
24839 PyObject * obj1 = 0 ;
24840 char * kwnames[] = {
24841 (char *) "self",(char *) "country", NULL
24842 };
24843
24844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24846 if (!SWIG_IsOK(res1)) {
24847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24848 }
24849 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24850 if (obj1) {
24851 ecode2 = SWIG_AsVal_int(obj1, &val2);
24852 if (!SWIG_IsOK(ecode2)) {
24853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24854 }
24855 arg2 = static_cast< wxDateTime::Country >(val2);
24856 }
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = (int)(arg1)->IsDST(arg2);
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 resultobj = SWIG_From_int(static_cast< int >(result));
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 PyObject *resultobj = 0;
24872 wxDateTime *arg1 = (wxDateTime *) 0 ;
24873 bool result;
24874 void *argp1 = 0 ;
24875 int res1 = 0 ;
24876 PyObject *swig_obj[1] ;
24877
24878 if (!args) SWIG_fail;
24879 swig_obj[0] = args;
24880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24881 if (!SWIG_IsOK(res1)) {
24882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24883 }
24884 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = (bool)((wxDateTime const *)arg1)->IsValid();
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 {
24892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24893 }
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24901 PyObject *resultobj = 0;
24902 wxDateTime *arg1 = (wxDateTime *) 0 ;
24903 time_t result;
24904 void *argp1 = 0 ;
24905 int res1 = 0 ;
24906 PyObject *swig_obj[1] ;
24907
24908 if (!args) SWIG_fail;
24909 swig_obj[0] = args;
24910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24911 if (!SWIG_IsOK(res1)) {
24912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24913 }
24914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxDateTime *arg1 = (wxDateTime *) 0 ;
24931 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24932 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24933 int result;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 bool temp2 = false ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "tz", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24947 }
24948 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24949 if (obj1) {
24950 {
24951 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24952 temp2 = true;
24953 }
24954 }
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 resultobj = SWIG_From_int(static_cast< int >(result));
24962 {
24963 if (temp2) delete arg2;
24964 }
24965 return resultobj;
24966 fail:
24967 {
24968 if (temp2) delete arg2;
24969 }
24970 return NULL;
24971 }
24972
24973
24974 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj = 0;
24976 wxDateTime *arg1 = (wxDateTime *) 0 ;
24977 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24978 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24979 wxDateTime::Month result;
24980 void *argp1 = 0 ;
24981 int res1 = 0 ;
24982 bool temp2 = false ;
24983 PyObject * obj0 = 0 ;
24984 PyObject * obj1 = 0 ;
24985 char * kwnames[] = {
24986 (char *) "self",(char *) "tz", NULL
24987 };
24988
24989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24993 }
24994 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24995 if (obj1) {
24996 {
24997 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24998 temp2 = true;
24999 }
25000 }
25001 {
25002 PyThreadState* __tstate = wxPyBeginAllowThreads();
25003 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 resultobj = SWIG_From_int(static_cast< int >(result));
25008 {
25009 if (temp2) delete arg2;
25010 }
25011 return resultobj;
25012 fail:
25013 {
25014 if (temp2) delete arg2;
25015 }
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxDateTime *arg1 = (wxDateTime *) 0 ;
25023 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25024 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25025 int result;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 bool temp2 = false ;
25029 PyObject * obj0 = 0 ;
25030 PyObject * obj1 = 0 ;
25031 char * kwnames[] = {
25032 (char *) "self",(char *) "tz", NULL
25033 };
25034
25035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25039 }
25040 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25041 if (obj1) {
25042 {
25043 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25044 temp2 = true;
25045 }
25046 }
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 resultobj = SWIG_From_int(static_cast< int >(result));
25054 {
25055 if (temp2) delete arg2;
25056 }
25057 return resultobj;
25058 fail:
25059 {
25060 if (temp2) delete arg2;
25061 }
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25067 PyObject *resultobj = 0;
25068 wxDateTime *arg1 = (wxDateTime *) 0 ;
25069 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25070 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25071 wxDateTime::WeekDay result;
25072 void *argp1 = 0 ;
25073 int res1 = 0 ;
25074 bool temp2 = false ;
25075 PyObject * obj0 = 0 ;
25076 PyObject * obj1 = 0 ;
25077 char * kwnames[] = {
25078 (char *) "self",(char *) "tz", NULL
25079 };
25080
25081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25083 if (!SWIG_IsOK(res1)) {
25084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25085 }
25086 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25087 if (obj1) {
25088 {
25089 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25090 temp2 = true;
25091 }
25092 }
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 resultobj = SWIG_From_int(static_cast< int >(result));
25100 {
25101 if (temp2) delete arg2;
25102 }
25103 return resultobj;
25104 fail:
25105 {
25106 if (temp2) delete arg2;
25107 }
25108 return NULL;
25109 }
25110
25111
25112 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj = 0;
25114 wxDateTime *arg1 = (wxDateTime *) 0 ;
25115 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25116 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25117 int result;
25118 void *argp1 = 0 ;
25119 int res1 = 0 ;
25120 bool temp2 = false ;
25121 PyObject * obj0 = 0 ;
25122 PyObject * obj1 = 0 ;
25123 char * kwnames[] = {
25124 (char *) "self",(char *) "tz", NULL
25125 };
25126
25127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25131 }
25132 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25133 if (obj1) {
25134 {
25135 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25136 temp2 = true;
25137 }
25138 }
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 resultobj = SWIG_From_int(static_cast< int >(result));
25146 {
25147 if (temp2) delete arg2;
25148 }
25149 return resultobj;
25150 fail:
25151 {
25152 if (temp2) delete arg2;
25153 }
25154 return NULL;
25155 }
25156
25157
25158 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 wxDateTime *arg1 = (wxDateTime *) 0 ;
25161 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25162 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25163 int result;
25164 void *argp1 = 0 ;
25165 int res1 = 0 ;
25166 bool temp2 = false ;
25167 PyObject * obj0 = 0 ;
25168 PyObject * obj1 = 0 ;
25169 char * kwnames[] = {
25170 (char *) "self",(char *) "tz", NULL
25171 };
25172
25173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25177 }
25178 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25179 if (obj1) {
25180 {
25181 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25182 temp2 = true;
25183 }
25184 }
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 resultobj = SWIG_From_int(static_cast< int >(result));
25192 {
25193 if (temp2) delete arg2;
25194 }
25195 return resultobj;
25196 fail:
25197 {
25198 if (temp2) delete arg2;
25199 }
25200 return NULL;
25201 }
25202
25203
25204 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25205 PyObject *resultobj = 0;
25206 wxDateTime *arg1 = (wxDateTime *) 0 ;
25207 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25208 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25209 int result;
25210 void *argp1 = 0 ;
25211 int res1 = 0 ;
25212 bool temp2 = false ;
25213 PyObject * obj0 = 0 ;
25214 PyObject * obj1 = 0 ;
25215 char * kwnames[] = {
25216 (char *) "self",(char *) "tz", NULL
25217 };
25218
25219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25221 if (!SWIG_IsOK(res1)) {
25222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25223 }
25224 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25225 if (obj1) {
25226 {
25227 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25228 temp2 = true;
25229 }
25230 }
25231 {
25232 PyThreadState* __tstate = wxPyBeginAllowThreads();
25233 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25234 wxPyEndAllowThreads(__tstate);
25235 if (PyErr_Occurred()) SWIG_fail;
25236 }
25237 resultobj = SWIG_From_int(static_cast< int >(result));
25238 {
25239 if (temp2) delete arg2;
25240 }
25241 return resultobj;
25242 fail:
25243 {
25244 if (temp2) delete arg2;
25245 }
25246 return NULL;
25247 }
25248
25249
25250 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 wxDateTime *arg1 = (wxDateTime *) 0 ;
25253 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25254 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25255 int result;
25256 void *argp1 = 0 ;
25257 int res1 = 0 ;
25258 bool temp2 = false ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "self",(char *) "tz", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25267 if (!SWIG_IsOK(res1)) {
25268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25269 }
25270 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25271 if (obj1) {
25272 {
25273 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25274 temp2 = true;
25275 }
25276 }
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25280 wxPyEndAllowThreads(__tstate);
25281 if (PyErr_Occurred()) SWIG_fail;
25282 }
25283 resultobj = SWIG_From_int(static_cast< int >(result));
25284 {
25285 if (temp2) delete arg2;
25286 }
25287 return resultobj;
25288 fail:
25289 {
25290 if (temp2) delete arg2;
25291 }
25292 return NULL;
25293 }
25294
25295
25296 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj = 0;
25298 wxDateTime *arg1 = (wxDateTime *) 0 ;
25299 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25300 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25301 int result;
25302 void *argp1 = 0 ;
25303 int res1 = 0 ;
25304 bool temp2 = false ;
25305 PyObject * obj0 = 0 ;
25306 PyObject * obj1 = 0 ;
25307 char * kwnames[] = {
25308 (char *) "self",(char *) "tz", NULL
25309 };
25310
25311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25313 if (!SWIG_IsOK(res1)) {
25314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25315 }
25316 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25317 if (obj1) {
25318 {
25319 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25320 temp2 = true;
25321 }
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_From_int(static_cast< int >(result));
25330 {
25331 if (temp2) delete arg2;
25332 }
25333 return resultobj;
25334 fail:
25335 {
25336 if (temp2) delete arg2;
25337 }
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25343 PyObject *resultobj = 0;
25344 wxDateTime *arg1 = (wxDateTime *) 0 ;
25345 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25346 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25347 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25348 int result;
25349 void *argp1 = 0 ;
25350 int res1 = 0 ;
25351 int val2 ;
25352 int ecode2 = 0 ;
25353 bool temp3 = false ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 PyObject * obj2 = 0 ;
25357 char * kwnames[] = {
25358 (char *) "self",(char *) "flags",(char *) "tz", NULL
25359 };
25360
25361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25363 if (!SWIG_IsOK(res1)) {
25364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25365 }
25366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25367 if (obj1) {
25368 ecode2 = SWIG_AsVal_int(obj1, &val2);
25369 if (!SWIG_IsOK(ecode2)) {
25370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25371 }
25372 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25373 }
25374 if (obj2) {
25375 {
25376 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25377 temp3 = true;
25378 }
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_From_int(static_cast< int >(result));
25387 {
25388 if (temp3) delete arg3;
25389 }
25390 return resultobj;
25391 fail:
25392 {
25393 if (temp3) delete arg3;
25394 }
25395 return NULL;
25396 }
25397
25398
25399 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj = 0;
25401 wxDateTime *arg1 = (wxDateTime *) 0 ;
25402 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25403 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25404 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25405 int result;
25406 void *argp1 = 0 ;
25407 int res1 = 0 ;
25408 int val2 ;
25409 int ecode2 = 0 ;
25410 bool temp3 = false ;
25411 PyObject * obj0 = 0 ;
25412 PyObject * obj1 = 0 ;
25413 PyObject * obj2 = 0 ;
25414 char * kwnames[] = {
25415 (char *) "self",(char *) "flags",(char *) "tz", NULL
25416 };
25417
25418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25420 if (!SWIG_IsOK(res1)) {
25421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25422 }
25423 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25424 if (obj1) {
25425 ecode2 = SWIG_AsVal_int(obj1, &val2);
25426 if (!SWIG_IsOK(ecode2)) {
25427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25428 }
25429 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25430 }
25431 if (obj2) {
25432 {
25433 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25434 temp3 = true;
25435 }
25436 }
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_From_int(static_cast< int >(result));
25444 {
25445 if (temp3) delete arg3;
25446 }
25447 return resultobj;
25448 fail:
25449 {
25450 if (temp3) delete arg3;
25451 }
25452 return NULL;
25453 }
25454
25455
25456 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj = 0;
25458 wxDateTime *arg1 = (wxDateTime *) 0 ;
25459 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25460 bool result;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 int val2 ;
25464 int ecode2 = 0 ;
25465 PyObject * obj0 = 0 ;
25466 PyObject * obj1 = 0 ;
25467 char * kwnames[] = {
25468 (char *) "self",(char *) "country", NULL
25469 };
25470
25471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25473 if (!SWIG_IsOK(res1)) {
25474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25475 }
25476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25477 if (obj1) {
25478 ecode2 = SWIG_AsVal_int(obj1, &val2);
25479 if (!SWIG_IsOK(ecode2)) {
25480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25481 }
25482 arg2 = static_cast< wxDateTime::Country >(val2);
25483 }
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 {
25491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25492 }
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj = 0;
25501 wxDateTime *arg1 = (wxDateTime *) 0 ;
25502 wxDateTime *arg2 = 0 ;
25503 bool result;
25504 void *argp1 = 0 ;
25505 int res1 = 0 ;
25506 void *argp2 = 0 ;
25507 int res2 = 0 ;
25508 PyObject * obj0 = 0 ;
25509 PyObject * obj1 = 0 ;
25510 char * kwnames[] = {
25511 (char *) "self",(char *) "datetime", NULL
25512 };
25513
25514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25516 if (!SWIG_IsOK(res1)) {
25517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25518 }
25519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25520 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25521 if (!SWIG_IsOK(res2)) {
25522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25523 }
25524 if (!argp2) {
25525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25526 }
25527 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25536 }
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj = 0;
25545 wxDateTime *arg1 = (wxDateTime *) 0 ;
25546 wxDateTime *arg2 = 0 ;
25547 bool result;
25548 void *argp1 = 0 ;
25549 int res1 = 0 ;
25550 void *argp2 = 0 ;
25551 int res2 = 0 ;
25552 PyObject * obj0 = 0 ;
25553 PyObject * obj1 = 0 ;
25554 char * kwnames[] = {
25555 (char *) "self",(char *) "datetime", NULL
25556 };
25557
25558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25560 if (!SWIG_IsOK(res1)) {
25561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25562 }
25563 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25565 if (!SWIG_IsOK(res2)) {
25566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25567 }
25568 if (!argp2) {
25569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25570 }
25571 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25572 {
25573 PyThreadState* __tstate = wxPyBeginAllowThreads();
25574 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25575 wxPyEndAllowThreads(__tstate);
25576 if (PyErr_Occurred()) SWIG_fail;
25577 }
25578 {
25579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25580 }
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25588 PyObject *resultobj = 0;
25589 wxDateTime *arg1 = (wxDateTime *) 0 ;
25590 wxDateTime *arg2 = 0 ;
25591 bool result;
25592 void *argp1 = 0 ;
25593 int res1 = 0 ;
25594 void *argp2 = 0 ;
25595 int res2 = 0 ;
25596 PyObject * obj0 = 0 ;
25597 PyObject * obj1 = 0 ;
25598 char * kwnames[] = {
25599 (char *) "self",(char *) "datetime", NULL
25600 };
25601
25602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25604 if (!SWIG_IsOK(res1)) {
25605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25606 }
25607 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25609 if (!SWIG_IsOK(res2)) {
25610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25611 }
25612 if (!argp2) {
25613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25614 }
25615 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj = 0;
25633 wxDateTime *arg1 = (wxDateTime *) 0 ;
25634 wxDateTime *arg2 = 0 ;
25635 wxDateTime *arg3 = 0 ;
25636 bool result;
25637 void *argp1 = 0 ;
25638 int res1 = 0 ;
25639 void *argp2 = 0 ;
25640 int res2 = 0 ;
25641 void *argp3 = 0 ;
25642 int res3 = 0 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 PyObject * obj2 = 0 ;
25646 char * kwnames[] = {
25647 (char *) "self",(char *) "t1",(char *) "t2", NULL
25648 };
25649
25650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25652 if (!SWIG_IsOK(res1)) {
25653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25654 }
25655 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25657 if (!SWIG_IsOK(res2)) {
25658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25659 }
25660 if (!argp2) {
25661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25662 }
25663 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25664 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25665 if (!SWIG_IsOK(res3)) {
25666 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25667 }
25668 if (!argp3) {
25669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25670 }
25671 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 {
25679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj = 0;
25689 wxDateTime *arg1 = (wxDateTime *) 0 ;
25690 wxDateTime *arg2 = 0 ;
25691 wxDateTime *arg3 = 0 ;
25692 bool result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 void *argp2 = 0 ;
25696 int res2 = 0 ;
25697 void *argp3 = 0 ;
25698 int res3 = 0 ;
25699 PyObject * obj0 = 0 ;
25700 PyObject * obj1 = 0 ;
25701 PyObject * obj2 = 0 ;
25702 char * kwnames[] = {
25703 (char *) "self",(char *) "t1",(char *) "t2", NULL
25704 };
25705
25706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25708 if (!SWIG_IsOK(res1)) {
25709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25710 }
25711 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25712 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25713 if (!SWIG_IsOK(res2)) {
25714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25715 }
25716 if (!argp2) {
25717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25718 }
25719 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25720 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25721 if (!SWIG_IsOK(res3)) {
25722 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25723 }
25724 if (!argp3) {
25725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25726 }
25727 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 {
25735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25736 }
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25744 PyObject *resultobj = 0;
25745 wxDateTime *arg1 = (wxDateTime *) 0 ;
25746 wxDateTime *arg2 = 0 ;
25747 bool result;
25748 void *argp1 = 0 ;
25749 int res1 = 0 ;
25750 void *argp2 = 0 ;
25751 int res2 = 0 ;
25752 PyObject * obj0 = 0 ;
25753 PyObject * obj1 = 0 ;
25754 char * kwnames[] = {
25755 (char *) "self",(char *) "dt", NULL
25756 };
25757
25758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25762 }
25763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25765 if (!SWIG_IsOK(res2)) {
25766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25767 }
25768 if (!argp2) {
25769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25770 }
25771 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25772 {
25773 PyThreadState* __tstate = wxPyBeginAllowThreads();
25774 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25775 wxPyEndAllowThreads(__tstate);
25776 if (PyErr_Occurred()) SWIG_fail;
25777 }
25778 {
25779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25780 }
25781 return resultobj;
25782 fail:
25783 return NULL;
25784 }
25785
25786
25787 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25788 PyObject *resultobj = 0;
25789 wxDateTime *arg1 = (wxDateTime *) 0 ;
25790 wxDateTime *arg2 = 0 ;
25791 bool result;
25792 void *argp1 = 0 ;
25793 int res1 = 0 ;
25794 void *argp2 = 0 ;
25795 int res2 = 0 ;
25796 PyObject * obj0 = 0 ;
25797 PyObject * obj1 = 0 ;
25798 char * kwnames[] = {
25799 (char *) "self",(char *) "dt", NULL
25800 };
25801
25802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25804 if (!SWIG_IsOK(res1)) {
25805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25806 }
25807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25809 if (!SWIG_IsOK(res2)) {
25810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25811 }
25812 if (!argp2) {
25813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25814 }
25815 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25816 {
25817 PyThreadState* __tstate = wxPyBeginAllowThreads();
25818 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25819 wxPyEndAllowThreads(__tstate);
25820 if (PyErr_Occurred()) SWIG_fail;
25821 }
25822 {
25823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25824 }
25825 return resultobj;
25826 fail:
25827 return NULL;
25828 }
25829
25830
25831 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25832 PyObject *resultobj = 0;
25833 wxDateTime *arg1 = (wxDateTime *) 0 ;
25834 wxDateTime *arg2 = 0 ;
25835 wxTimeSpan *arg3 = 0 ;
25836 bool result;
25837 void *argp1 = 0 ;
25838 int res1 = 0 ;
25839 void *argp2 = 0 ;
25840 int res2 = 0 ;
25841 void *argp3 = 0 ;
25842 int res3 = 0 ;
25843 PyObject * obj0 = 0 ;
25844 PyObject * obj1 = 0 ;
25845 PyObject * obj2 = 0 ;
25846 char * kwnames[] = {
25847 (char *) "self",(char *) "dt",(char *) "ts", NULL
25848 };
25849
25850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25852 if (!SWIG_IsOK(res1)) {
25853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25854 }
25855 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25857 if (!SWIG_IsOK(res2)) {
25858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25859 }
25860 if (!argp2) {
25861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25862 }
25863 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25864 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25865 if (!SWIG_IsOK(res3)) {
25866 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25867 }
25868 if (!argp3) {
25869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25870 }
25871 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25872 {
25873 PyThreadState* __tstate = wxPyBeginAllowThreads();
25874 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25875 wxPyEndAllowThreads(__tstate);
25876 if (PyErr_Occurred()) SWIG_fail;
25877 }
25878 {
25879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25880 }
25881 return resultobj;
25882 fail:
25883 return NULL;
25884 }
25885
25886
25887 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25888 PyObject *resultobj = 0;
25889 wxDateTime *arg1 = (wxDateTime *) 0 ;
25890 wxTimeSpan *arg2 = 0 ;
25891 wxDateTime *result = 0 ;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 void *argp2 = 0 ;
25895 int res2 = 0 ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char * kwnames[] = {
25899 (char *) "self",(char *) "diff", NULL
25900 };
25901
25902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25904 if (!SWIG_IsOK(res1)) {
25905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25906 }
25907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25909 if (!SWIG_IsOK(res2)) {
25910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25911 }
25912 if (!argp2) {
25913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25914 }
25915 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25916 {
25917 PyThreadState* __tstate = wxPyBeginAllowThreads();
25918 {
25919 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25920 result = (wxDateTime *) &_result_ref;
25921 }
25922 wxPyEndAllowThreads(__tstate);
25923 if (PyErr_Occurred()) SWIG_fail;
25924 }
25925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25926 return resultobj;
25927 fail:
25928 return NULL;
25929 }
25930
25931
25932 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25933 PyObject *resultobj = 0;
25934 wxDateTime *arg1 = (wxDateTime *) 0 ;
25935 wxDateSpan *arg2 = 0 ;
25936 wxDateTime *result = 0 ;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 void *argp2 = 0 ;
25940 int res2 = 0 ;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char * kwnames[] = {
25944 (char *) "self",(char *) "diff", NULL
25945 };
25946
25947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25951 }
25952 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25954 if (!SWIG_IsOK(res2)) {
25955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25956 }
25957 if (!argp2) {
25958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25959 }
25960 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 {
25964 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25965 result = (wxDateTime *) &_result_ref;
25966 }
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25971 return resultobj;
25972 fail:
25973 return NULL;
25974 }
25975
25976
25977 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25978 PyObject *resultobj = 0;
25979 wxDateTime *arg1 = (wxDateTime *) 0 ;
25980 wxTimeSpan *arg2 = 0 ;
25981 wxDateTime *result = 0 ;
25982 void *argp1 = 0 ;
25983 int res1 = 0 ;
25984 void *argp2 = 0 ;
25985 int res2 = 0 ;
25986 PyObject * obj0 = 0 ;
25987 PyObject * obj1 = 0 ;
25988 char * kwnames[] = {
25989 (char *) "self",(char *) "diff", NULL
25990 };
25991
25992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25994 if (!SWIG_IsOK(res1)) {
25995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25996 }
25997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25999 if (!SWIG_IsOK(res2)) {
26000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26001 }
26002 if (!argp2) {
26003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26004 }
26005 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26006 {
26007 PyThreadState* __tstate = wxPyBeginAllowThreads();
26008 {
26009 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26010 result = (wxDateTime *) &_result_ref;
26011 }
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26016 return resultobj;
26017 fail:
26018 return NULL;
26019 }
26020
26021
26022 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26023 PyObject *resultobj = 0;
26024 wxDateTime *arg1 = (wxDateTime *) 0 ;
26025 wxDateSpan *arg2 = 0 ;
26026 wxDateTime *result = 0 ;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 void *argp2 = 0 ;
26030 int res2 = 0 ;
26031 PyObject * obj0 = 0 ;
26032 PyObject * obj1 = 0 ;
26033 char * kwnames[] = {
26034 (char *) "self",(char *) "diff", NULL
26035 };
26036
26037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26039 if (!SWIG_IsOK(res1)) {
26040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26041 }
26042 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26044 if (!SWIG_IsOK(res2)) {
26045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26046 }
26047 if (!argp2) {
26048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26049 }
26050 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 {
26054 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26055 result = (wxDateTime *) &_result_ref;
26056 }
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj = 0;
26069 wxDateTime *arg1 = (wxDateTime *) 0 ;
26070 wxDateTime *arg2 = 0 ;
26071 wxTimeSpan result;
26072 void *argp1 = 0 ;
26073 int res1 = 0 ;
26074 void *argp2 = 0 ;
26075 int res2 = 0 ;
26076 PyObject * obj0 = 0 ;
26077 PyObject * obj1 = 0 ;
26078 char * kwnames[] = {
26079 (char *) "self",(char *) "dt", NULL
26080 };
26081
26082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26084 if (!SWIG_IsOK(res1)) {
26085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26086 }
26087 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26089 if (!SWIG_IsOK(res2)) {
26090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26091 }
26092 if (!argp2) {
26093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26094 }
26095 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26103 return resultobj;
26104 fail:
26105 return NULL;
26106 }
26107
26108
26109 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26110 PyObject *resultobj = 0;
26111 wxDateTime *arg1 = (wxDateTime *) 0 ;
26112 wxTimeSpan *arg2 = 0 ;
26113 wxDateTime *result = 0 ;
26114 void *argp1 = 0 ;
26115 int res1 = 0 ;
26116 void *argp2 = 0 ;
26117 int res2 = 0 ;
26118
26119 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26121 if (!SWIG_IsOK(res1)) {
26122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26123 }
26124 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26125 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26126 if (!SWIG_IsOK(res2)) {
26127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26128 }
26129 if (!argp2) {
26130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26131 }
26132 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 {
26136 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26137 result = (wxDateTime *) &_result_ref;
26138 }
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26143 return resultobj;
26144 fail:
26145 return NULL;
26146 }
26147
26148
26149 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26150 PyObject *resultobj = 0;
26151 wxDateTime *arg1 = (wxDateTime *) 0 ;
26152 wxDateSpan *arg2 = 0 ;
26153 wxDateTime *result = 0 ;
26154 void *argp1 = 0 ;
26155 int res1 = 0 ;
26156 void *argp2 = 0 ;
26157 int res2 = 0 ;
26158
26159 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26163 }
26164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26165 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26166 if (!SWIG_IsOK(res2)) {
26167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26168 }
26169 if (!argp2) {
26170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26171 }
26172 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26173 {
26174 PyThreadState* __tstate = wxPyBeginAllowThreads();
26175 {
26176 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26177 result = (wxDateTime *) &_result_ref;
26178 }
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26190 int argc;
26191 PyObject *argv[3];
26192
26193 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26194 --argc;
26195 if (argc == 2) {
26196 int _v = 0;
26197 {
26198 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26199 _v = SWIG_CheckState(res);
26200 }
26201 if (!_v) goto check_1;
26202 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26203 }
26204 check_1:
26205
26206 if (argc == 2) {
26207 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26208 }
26209
26210 fail:
26211 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26212 return NULL;
26213 }
26214
26215
26216 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26217 PyObject *resultobj = 0;
26218 wxDateTime *arg1 = (wxDateTime *) 0 ;
26219 wxTimeSpan *arg2 = 0 ;
26220 wxDateTime *result = 0 ;
26221 void *argp1 = 0 ;
26222 int res1 = 0 ;
26223 void *argp2 = 0 ;
26224 int res2 = 0 ;
26225
26226 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26228 if (!SWIG_IsOK(res1)) {
26229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26230 }
26231 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26232 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26233 if (!SWIG_IsOK(res2)) {
26234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26235 }
26236 if (!argp2) {
26237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26238 }
26239 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 {
26243 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26244 result = (wxDateTime *) &_result_ref;
26245 }
26246 wxPyEndAllowThreads(__tstate);
26247 if (PyErr_Occurred()) SWIG_fail;
26248 }
26249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26257 PyObject *resultobj = 0;
26258 wxDateTime *arg1 = (wxDateTime *) 0 ;
26259 wxDateSpan *arg2 = 0 ;
26260 wxDateTime *result = 0 ;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 void *argp2 = 0 ;
26264 int res2 = 0 ;
26265
26266 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26270 }
26271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26272 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26273 if (!SWIG_IsOK(res2)) {
26274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26275 }
26276 if (!argp2) {
26277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26278 }
26279 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 {
26283 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26284 result = (wxDateTime *) &_result_ref;
26285 }
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26297 int argc;
26298 PyObject *argv[3];
26299
26300 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26301 --argc;
26302 if (argc == 2) {
26303 int _v = 0;
26304 {
26305 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26306 _v = SWIG_CheckState(res);
26307 }
26308 if (!_v) goto check_1;
26309 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26310 }
26311 check_1:
26312
26313 if (argc == 2) {
26314 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26315 }
26316
26317 fail:
26318 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26319 return NULL;
26320 }
26321
26322
26323 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26324 PyObject *resultobj = 0;
26325 wxDateTime *arg1 = (wxDateTime *) 0 ;
26326 wxTimeSpan *arg2 = 0 ;
26327 wxDateTime result;
26328 void *argp1 = 0 ;
26329 int res1 = 0 ;
26330 void *argp2 = 0 ;
26331 int res2 = 0 ;
26332
26333 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26335 if (!SWIG_IsOK(res1)) {
26336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26337 }
26338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26339 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26340 if (!SWIG_IsOK(res2)) {
26341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26342 }
26343 if (!argp2) {
26344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26345 }
26346 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26361 PyObject *resultobj = 0;
26362 wxDateTime *arg1 = (wxDateTime *) 0 ;
26363 wxDateSpan *arg2 = 0 ;
26364 wxDateTime result;
26365 void *argp1 = 0 ;
26366 int res1 = 0 ;
26367 void *argp2 = 0 ;
26368 int res2 = 0 ;
26369
26370 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26372 if (!SWIG_IsOK(res1)) {
26373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26374 }
26375 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26376 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26377 if (!SWIG_IsOK(res2)) {
26378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26379 }
26380 if (!argp2) {
26381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26382 }
26383 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26398 int argc;
26399 PyObject *argv[3];
26400
26401 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26402 --argc;
26403 if (argc == 2) {
26404 int _v = 0;
26405 {
26406 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26407 _v = SWIG_CheckState(res);
26408 }
26409 if (!_v) goto check_1;
26410 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26411 }
26412 check_1:
26413
26414 if (argc == 2) {
26415 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26416 }
26417
26418 fail:
26419 Py_INCREF(Py_NotImplemented);
26420 return Py_NotImplemented;
26421 }
26422
26423
26424 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26425 PyObject *resultobj = 0;
26426 wxDateTime *arg1 = (wxDateTime *) 0 ;
26427 wxDateTime *arg2 = 0 ;
26428 wxTimeSpan result;
26429 void *argp1 = 0 ;
26430 int res1 = 0 ;
26431 void *argp2 = 0 ;
26432 int res2 = 0 ;
26433
26434 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26436 if (!SWIG_IsOK(res1)) {
26437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26438 }
26439 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26440 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26441 if (!SWIG_IsOK(res2)) {
26442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26443 }
26444 if (!argp2) {
26445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26446 }
26447 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26462 PyObject *resultobj = 0;
26463 wxDateTime *arg1 = (wxDateTime *) 0 ;
26464 wxTimeSpan *arg2 = 0 ;
26465 wxDateTime result;
26466 void *argp1 = 0 ;
26467 int res1 = 0 ;
26468 void *argp2 = 0 ;
26469 int res2 = 0 ;
26470
26471 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26473 if (!SWIG_IsOK(res1)) {
26474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26475 }
26476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26477 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26478 if (!SWIG_IsOK(res2)) {
26479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26480 }
26481 if (!argp2) {
26482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26483 }
26484 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26499 PyObject *resultobj = 0;
26500 wxDateTime *arg1 = (wxDateTime *) 0 ;
26501 wxDateSpan *arg2 = 0 ;
26502 wxDateTime result;
26503 void *argp1 = 0 ;
26504 int res1 = 0 ;
26505 void *argp2 = 0 ;
26506 int res2 = 0 ;
26507
26508 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26510 if (!SWIG_IsOK(res1)) {
26511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26512 }
26513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26515 if (!SWIG_IsOK(res2)) {
26516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26517 }
26518 if (!argp2) {
26519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26520 }
26521 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26522 {
26523 PyThreadState* __tstate = wxPyBeginAllowThreads();
26524 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26525 wxPyEndAllowThreads(__tstate);
26526 if (PyErr_Occurred()) SWIG_fail;
26527 }
26528 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26529 return resultobj;
26530 fail:
26531 return NULL;
26532 }
26533
26534
26535 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26536 int argc;
26537 PyObject *argv[3];
26538
26539 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26540 --argc;
26541 if (argc == 2) {
26542 int _v = 0;
26543 {
26544 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26545 _v = SWIG_CheckState(res);
26546 }
26547 if (!_v) goto check_1;
26548 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26549 }
26550 check_1:
26551
26552 if (argc == 2) {
26553 int _v = 0;
26554 {
26555 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26556 _v = SWIG_CheckState(res);
26557 }
26558 if (!_v) goto check_2;
26559 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26560 }
26561 check_2:
26562
26563 if (argc == 2) {
26564 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26565 }
26566
26567 fail:
26568 Py_INCREF(Py_NotImplemented);
26569 return Py_NotImplemented;
26570 }
26571
26572
26573 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj = 0;
26575 wxDateTime *arg1 = (wxDateTime *) 0 ;
26576 wxDateTime *arg2 = (wxDateTime *) 0 ;
26577 bool result;
26578 void *argp1 = 0 ;
26579 int res1 = 0 ;
26580 void *argp2 = 0 ;
26581 int res2 = 0 ;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "self",(char *) "other", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26592 }
26593 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26595 if (!SWIG_IsOK(res2)) {
26596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26597 }
26598 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26599 {
26600 PyThreadState* __tstate = wxPyBeginAllowThreads();
26601 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 {
26606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26607 }
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26615 PyObject *resultobj = 0;
26616 wxDateTime *arg1 = (wxDateTime *) 0 ;
26617 wxDateTime *arg2 = (wxDateTime *) 0 ;
26618 bool result;
26619 void *argp1 = 0 ;
26620 int res1 = 0 ;
26621 void *argp2 = 0 ;
26622 int res2 = 0 ;
26623 PyObject * obj0 = 0 ;
26624 PyObject * obj1 = 0 ;
26625 char * kwnames[] = {
26626 (char *) "self",(char *) "other", NULL
26627 };
26628
26629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26631 if (!SWIG_IsOK(res1)) {
26632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26633 }
26634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26636 if (!SWIG_IsOK(res2)) {
26637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26638 }
26639 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 {
26647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26648 }
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj = 0;
26657 wxDateTime *arg1 = (wxDateTime *) 0 ;
26658 wxDateTime *arg2 = (wxDateTime *) 0 ;
26659 bool result;
26660 void *argp1 = 0 ;
26661 int res1 = 0 ;
26662 void *argp2 = 0 ;
26663 int res2 = 0 ;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 char * kwnames[] = {
26667 (char *) "self",(char *) "other", NULL
26668 };
26669
26670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26672 if (!SWIG_IsOK(res1)) {
26673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26674 }
26675 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26677 if (!SWIG_IsOK(res2)) {
26678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26679 }
26680 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 {
26688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26689 }
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26697 PyObject *resultobj = 0;
26698 wxDateTime *arg1 = (wxDateTime *) 0 ;
26699 wxDateTime *arg2 = (wxDateTime *) 0 ;
26700 bool result;
26701 void *argp1 = 0 ;
26702 int res1 = 0 ;
26703 void *argp2 = 0 ;
26704 int res2 = 0 ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "self",(char *) "other", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26715 }
26716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26718 if (!SWIG_IsOK(res2)) {
26719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26720 }
26721 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 {
26729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26730 }
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26738 PyObject *resultobj = 0;
26739 wxDateTime *arg1 = (wxDateTime *) 0 ;
26740 wxDateTime *arg2 = (wxDateTime *) 0 ;
26741 bool result;
26742 void *argp1 = 0 ;
26743 int res1 = 0 ;
26744 void *argp2 = 0 ;
26745 int res2 = 0 ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 char * kwnames[] = {
26749 (char *) "self",(char *) "other", NULL
26750 };
26751
26752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26754 if (!SWIG_IsOK(res1)) {
26755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26756 }
26757 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26759 if (!SWIG_IsOK(res2)) {
26760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26761 }
26762 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26766 wxPyEndAllowThreads(__tstate);
26767 if (PyErr_Occurred()) SWIG_fail;
26768 }
26769 {
26770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26771 }
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj = 0;
26780 wxDateTime *arg1 = (wxDateTime *) 0 ;
26781 wxDateTime *arg2 = (wxDateTime *) 0 ;
26782 bool result;
26783 void *argp1 = 0 ;
26784 int res1 = 0 ;
26785 void *argp2 = 0 ;
26786 int res2 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 PyObject * obj1 = 0 ;
26789 char * kwnames[] = {
26790 (char *) "self",(char *) "other", NULL
26791 };
26792
26793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26797 }
26798 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26800 if (!SWIG_IsOK(res2)) {
26801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26802 }
26803 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26804 {
26805 PyThreadState* __tstate = wxPyBeginAllowThreads();
26806 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26807 wxPyEndAllowThreads(__tstate);
26808 if (PyErr_Occurred()) SWIG_fail;
26809 }
26810 {
26811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26812 }
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26820 PyObject *resultobj = 0;
26821 wxDateTime *arg1 = (wxDateTime *) 0 ;
26822 wxString *arg2 = 0 ;
26823 int result;
26824 void *argp1 = 0 ;
26825 int res1 = 0 ;
26826 bool temp2 = false ;
26827 PyObject * obj0 = 0 ;
26828 PyObject * obj1 = 0 ;
26829 char * kwnames[] = {
26830 (char *) "self",(char *) "date", NULL
26831 };
26832
26833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26835 if (!SWIG_IsOK(res1)) {
26836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26837 }
26838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26839 {
26840 arg2 = wxString_in_helper(obj1);
26841 if (arg2 == NULL) SWIG_fail;
26842 temp2 = true;
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 resultobj = SWIG_From_int(static_cast< int >(result));
26851 {
26852 if (temp2)
26853 delete arg2;
26854 }
26855 return resultobj;
26856 fail:
26857 {
26858 if (temp2)
26859 delete arg2;
26860 }
26861 return NULL;
26862 }
26863
26864
26865 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26866 PyObject *resultobj = 0;
26867 wxDateTime *arg1 = (wxDateTime *) 0 ;
26868 wxString *arg2 = 0 ;
26869 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26870 wxString *arg3 = (wxString *) &arg3_defvalue ;
26871 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26872 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26873 int result;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 bool temp2 = false ;
26877 bool temp3 = false ;
26878 void *argp4 = 0 ;
26879 int res4 = 0 ;
26880 PyObject * obj0 = 0 ;
26881 PyObject * obj1 = 0 ;
26882 PyObject * obj2 = 0 ;
26883 PyObject * obj3 = 0 ;
26884 char * kwnames[] = {
26885 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26886 };
26887
26888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26890 if (!SWIG_IsOK(res1)) {
26891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26892 }
26893 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26894 {
26895 arg2 = wxString_in_helper(obj1);
26896 if (arg2 == NULL) SWIG_fail;
26897 temp2 = true;
26898 }
26899 if (obj2) {
26900 {
26901 arg3 = wxString_in_helper(obj2);
26902 if (arg3 == NULL) SWIG_fail;
26903 temp3 = true;
26904 }
26905 }
26906 if (obj3) {
26907 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26908 if (!SWIG_IsOK(res4)) {
26909 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26910 }
26911 if (!argp4) {
26912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26913 }
26914 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26915 }
26916 {
26917 PyThreadState* __tstate = wxPyBeginAllowThreads();
26918 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 resultobj = SWIG_From_int(static_cast< int >(result));
26923 {
26924 if (temp2)
26925 delete arg2;
26926 }
26927 {
26928 if (temp3)
26929 delete arg3;
26930 }
26931 return resultobj;
26932 fail:
26933 {
26934 if (temp2)
26935 delete arg2;
26936 }
26937 {
26938 if (temp3)
26939 delete arg3;
26940 }
26941 return NULL;
26942 }
26943
26944
26945 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj = 0;
26947 wxDateTime *arg1 = (wxDateTime *) 0 ;
26948 wxString *arg2 = 0 ;
26949 int result;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 bool temp2 = false ;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "self",(char *) "datetime", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26963 }
26964 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26965 {
26966 arg2 = wxString_in_helper(obj1);
26967 if (arg2 == NULL) SWIG_fail;
26968 temp2 = true;
26969 }
26970 {
26971 PyThreadState* __tstate = wxPyBeginAllowThreads();
26972 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26973 wxPyEndAllowThreads(__tstate);
26974 if (PyErr_Occurred()) SWIG_fail;
26975 }
26976 resultobj = SWIG_From_int(static_cast< int >(result));
26977 {
26978 if (temp2)
26979 delete arg2;
26980 }
26981 return resultobj;
26982 fail:
26983 {
26984 if (temp2)
26985 delete arg2;
26986 }
26987 return NULL;
26988 }
26989
26990
26991 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26992 PyObject *resultobj = 0;
26993 wxDateTime *arg1 = (wxDateTime *) 0 ;
26994 wxString *arg2 = 0 ;
26995 int result;
26996 void *argp1 = 0 ;
26997 int res1 = 0 ;
26998 bool temp2 = false ;
26999 PyObject * obj0 = 0 ;
27000 PyObject * obj1 = 0 ;
27001 char * kwnames[] = {
27002 (char *) "self",(char *) "date", NULL
27003 };
27004
27005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27007 if (!SWIG_IsOK(res1)) {
27008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27009 }
27010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27011 {
27012 arg2 = wxString_in_helper(obj1);
27013 if (arg2 == NULL) SWIG_fail;
27014 temp2 = true;
27015 }
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 resultobj = SWIG_From_int(static_cast< int >(result));
27023 {
27024 if (temp2)
27025 delete arg2;
27026 }
27027 return resultobj;
27028 fail:
27029 {
27030 if (temp2)
27031 delete arg2;
27032 }
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj = 0;
27039 wxDateTime *arg1 = (wxDateTime *) 0 ;
27040 wxString *arg2 = 0 ;
27041 int result;
27042 void *argp1 = 0 ;
27043 int res1 = 0 ;
27044 bool temp2 = false ;
27045 PyObject * obj0 = 0 ;
27046 PyObject * obj1 = 0 ;
27047 char * kwnames[] = {
27048 (char *) "self",(char *) "time", NULL
27049 };
27050
27051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27053 if (!SWIG_IsOK(res1)) {
27054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27055 }
27056 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27057 {
27058 arg2 = wxString_in_helper(obj1);
27059 if (arg2 == NULL) SWIG_fail;
27060 temp2 = true;
27061 }
27062 {
27063 PyThreadState* __tstate = wxPyBeginAllowThreads();
27064 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 resultobj = SWIG_From_int(static_cast< int >(result));
27069 {
27070 if (temp2)
27071 delete arg2;
27072 }
27073 return resultobj;
27074 fail:
27075 {
27076 if (temp2)
27077 delete arg2;
27078 }
27079 return NULL;
27080 }
27081
27082
27083 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj = 0;
27085 wxDateTime *arg1 = (wxDateTime *) 0 ;
27086 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27087 wxString *arg2 = (wxString *) &arg2_defvalue ;
27088 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27089 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27090 wxString result;
27091 void *argp1 = 0 ;
27092 int res1 = 0 ;
27093 bool temp2 = false ;
27094 bool temp3 = false ;
27095 PyObject * obj0 = 0 ;
27096 PyObject * obj1 = 0 ;
27097 PyObject * obj2 = 0 ;
27098 char * kwnames[] = {
27099 (char *) "self",(char *) "format",(char *) "tz", NULL
27100 };
27101
27102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27104 if (!SWIG_IsOK(res1)) {
27105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27106 }
27107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27108 if (obj1) {
27109 {
27110 arg2 = wxString_in_helper(obj1);
27111 if (arg2 == NULL) SWIG_fail;
27112 temp2 = true;
27113 }
27114 }
27115 if (obj2) {
27116 {
27117 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27118 temp3 = true;
27119 }
27120 }
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 #if wxUSE_UNICODE
27129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27130 #else
27131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27132 #endif
27133 }
27134 {
27135 if (temp2)
27136 delete arg2;
27137 }
27138 {
27139 if (temp3) delete arg3;
27140 }
27141 return resultobj;
27142 fail:
27143 {
27144 if (temp2)
27145 delete arg2;
27146 }
27147 {
27148 if (temp3) delete arg3;
27149 }
27150 return NULL;
27151 }
27152
27153
27154 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27155 PyObject *resultobj = 0;
27156 wxDateTime *arg1 = (wxDateTime *) 0 ;
27157 wxString result;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 PyObject *swig_obj[1] ;
27161
27162 if (!args) SWIG_fail;
27163 swig_obj[0] = args;
27164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27167 }
27168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = ((wxDateTime const *)arg1)->FormatDate();
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 #if wxUSE_UNICODE
27177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27178 #else
27179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27180 #endif
27181 }
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27189 PyObject *resultobj = 0;
27190 wxDateTime *arg1 = (wxDateTime *) 0 ;
27191 wxString result;
27192 void *argp1 = 0 ;
27193 int res1 = 0 ;
27194 PyObject *swig_obj[1] ;
27195
27196 if (!args) SWIG_fail;
27197 swig_obj[0] = args;
27198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27199 if (!SWIG_IsOK(res1)) {
27200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27201 }
27202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 result = ((wxDateTime const *)arg1)->FormatTime();
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 {
27210 #if wxUSE_UNICODE
27211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27212 #else
27213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27214 #endif
27215 }
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27223 PyObject *resultobj = 0;
27224 wxDateTime *arg1 = (wxDateTime *) 0 ;
27225 wxString result;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 PyObject *swig_obj[1] ;
27229
27230 if (!args) SWIG_fail;
27231 swig_obj[0] = args;
27232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27233 if (!SWIG_IsOK(res1)) {
27234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27235 }
27236 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 result = ((wxDateTime const *)arg1)->FormatISODate();
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 {
27244 #if wxUSE_UNICODE
27245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27246 #else
27247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27248 #endif
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27257 PyObject *resultobj = 0;
27258 wxDateTime *arg1 = (wxDateTime *) 0 ;
27259 wxString result;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 PyObject *swig_obj[1] ;
27263
27264 if (!args) SWIG_fail;
27265 swig_obj[0] = args;
27266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27267 if (!SWIG_IsOK(res1)) {
27268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27269 }
27270 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = ((wxDateTime const *)arg1)->FormatISOTime();
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 {
27278 #if wxUSE_UNICODE
27279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27280 #else
27281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27282 #endif
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27291 PyObject *obj;
27292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27293 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27294 return SWIG_Py_Void();
27295 }
27296
27297 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27298 return SWIG_Python_InitShadowInstance(args);
27299 }
27300
27301 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27302 PyObject *resultobj = 0;
27303 long arg1 ;
27304 wxTimeSpan result;
27305 long val1 ;
27306 int ecode1 = 0 ;
27307 PyObject * obj0 = 0 ;
27308 char * kwnames[] = {
27309 (char *) "sec", NULL
27310 };
27311
27312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27313 ecode1 = SWIG_AsVal_long(obj0, &val1);
27314 if (!SWIG_IsOK(ecode1)) {
27315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27316 }
27317 arg1 = static_cast< long >(val1);
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 result = wxTimeSpan::Seconds(arg1);
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27332 PyObject *resultobj = 0;
27333 wxTimeSpan result;
27334
27335 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = wxTimeSpan::Second();
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27350 PyObject *resultobj = 0;
27351 long arg1 ;
27352 wxTimeSpan result;
27353 long val1 ;
27354 int ecode1 = 0 ;
27355 PyObject * obj0 = 0 ;
27356 char * kwnames[] = {
27357 (char *) "min", NULL
27358 };
27359
27360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27361 ecode1 = SWIG_AsVal_long(obj0, &val1);
27362 if (!SWIG_IsOK(ecode1)) {
27363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27364 }
27365 arg1 = static_cast< long >(val1);
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = wxTimeSpan::Minutes(arg1);
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27380 PyObject *resultobj = 0;
27381 wxTimeSpan result;
27382
27383 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 result = wxTimeSpan::Minute();
27387 wxPyEndAllowThreads(__tstate);
27388 if (PyErr_Occurred()) SWIG_fail;
27389 }
27390 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27398 PyObject *resultobj = 0;
27399 long arg1 ;
27400 wxTimeSpan result;
27401 long val1 ;
27402 int ecode1 = 0 ;
27403 PyObject * obj0 = 0 ;
27404 char * kwnames[] = {
27405 (char *) "hours", NULL
27406 };
27407
27408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27409 ecode1 = SWIG_AsVal_long(obj0, &val1);
27410 if (!SWIG_IsOK(ecode1)) {
27411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27412 }
27413 arg1 = static_cast< long >(val1);
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = wxTimeSpan::Hours(arg1);
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27428 PyObject *resultobj = 0;
27429 wxTimeSpan result;
27430
27431 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = wxTimeSpan::Hour();
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj = 0;
27447 long arg1 ;
27448 wxTimeSpan result;
27449 long val1 ;
27450 int ecode1 = 0 ;
27451 PyObject * obj0 = 0 ;
27452 char * kwnames[] = {
27453 (char *) "days", NULL
27454 };
27455
27456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27457 ecode1 = SWIG_AsVal_long(obj0, &val1);
27458 if (!SWIG_IsOK(ecode1)) {
27459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27460 }
27461 arg1 = static_cast< long >(val1);
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 result = wxTimeSpan::Days(arg1);
27465 wxPyEndAllowThreads(__tstate);
27466 if (PyErr_Occurred()) SWIG_fail;
27467 }
27468 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *resultobj = 0;
27477 wxTimeSpan result;
27478
27479 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 result = wxTimeSpan::Day();
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj = 0;
27495 long arg1 ;
27496 wxTimeSpan result;
27497 long val1 ;
27498 int ecode1 = 0 ;
27499 PyObject * obj0 = 0 ;
27500 char * kwnames[] = {
27501 (char *) "days", NULL
27502 };
27503
27504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27505 ecode1 = SWIG_AsVal_long(obj0, &val1);
27506 if (!SWIG_IsOK(ecode1)) {
27507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27508 }
27509 arg1 = static_cast< long >(val1);
27510 {
27511 PyThreadState* __tstate = wxPyBeginAllowThreads();
27512 result = wxTimeSpan::Weeks(arg1);
27513 wxPyEndAllowThreads(__tstate);
27514 if (PyErr_Occurred()) SWIG_fail;
27515 }
27516 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27517 return resultobj;
27518 fail:
27519 return NULL;
27520 }
27521
27522
27523 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27524 PyObject *resultobj = 0;
27525 wxTimeSpan result;
27526
27527 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 result = wxTimeSpan::Week();
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj = 0;
27543 long arg1 = (long) 0 ;
27544 long arg2 = (long) 0 ;
27545 long arg3 = (long) 0 ;
27546 long arg4 = (long) 0 ;
27547 wxTimeSpan *result = 0 ;
27548 long val1 ;
27549 int ecode1 = 0 ;
27550 long val2 ;
27551 int ecode2 = 0 ;
27552 long val3 ;
27553 int ecode3 = 0 ;
27554 long val4 ;
27555 int ecode4 = 0 ;
27556 PyObject * obj0 = 0 ;
27557 PyObject * obj1 = 0 ;
27558 PyObject * obj2 = 0 ;
27559 PyObject * obj3 = 0 ;
27560 char * kwnames[] = {
27561 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27562 };
27563
27564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27565 if (obj0) {
27566 ecode1 = SWIG_AsVal_long(obj0, &val1);
27567 if (!SWIG_IsOK(ecode1)) {
27568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27569 }
27570 arg1 = static_cast< long >(val1);
27571 }
27572 if (obj1) {
27573 ecode2 = SWIG_AsVal_long(obj1, &val2);
27574 if (!SWIG_IsOK(ecode2)) {
27575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27576 }
27577 arg2 = static_cast< long >(val2);
27578 }
27579 if (obj2) {
27580 ecode3 = SWIG_AsVal_long(obj2, &val3);
27581 if (!SWIG_IsOK(ecode3)) {
27582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27583 }
27584 arg3 = static_cast< long >(val3);
27585 }
27586 if (obj3) {
27587 ecode4 = SWIG_AsVal_long(obj3, &val4);
27588 if (!SWIG_IsOK(ecode4)) {
27589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27590 }
27591 arg4 = static_cast< long >(val4);
27592 }
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 PyObject *resultobj = 0;
27608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27609 void *argp1 = 0 ;
27610 int res1 = 0 ;
27611 PyObject *swig_obj[1] ;
27612
27613 if (!args) SWIG_fail;
27614 swig_obj[0] = args;
27615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27616 if (!SWIG_IsOK(res1)) {
27617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27618 }
27619 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 delete arg1;
27623
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 resultobj = SWIG_Py_Void();
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj = 0;
27636 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27637 wxTimeSpan *arg2 = 0 ;
27638 wxTimeSpan *result = 0 ;
27639 void *argp1 = 0 ;
27640 int res1 = 0 ;
27641 void *argp2 = 0 ;
27642 int res2 = 0 ;
27643 PyObject * obj0 = 0 ;
27644 PyObject * obj1 = 0 ;
27645 char * kwnames[] = {
27646 (char *) "self",(char *) "diff", NULL
27647 };
27648
27649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27651 if (!SWIG_IsOK(res1)) {
27652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27653 }
27654 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27655 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27656 if (!SWIG_IsOK(res2)) {
27657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27658 }
27659 if (!argp2) {
27660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27661 }
27662 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 {
27666 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27667 result = (wxTimeSpan *) &_result_ref;
27668 }
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj = 0;
27681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27682 wxTimeSpan *arg2 = 0 ;
27683 wxTimeSpan *result = 0 ;
27684 void *argp1 = 0 ;
27685 int res1 = 0 ;
27686 void *argp2 = 0 ;
27687 int res2 = 0 ;
27688 PyObject * obj0 = 0 ;
27689 PyObject * obj1 = 0 ;
27690 char * kwnames[] = {
27691 (char *) "self",(char *) "diff", NULL
27692 };
27693
27694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27696 if (!SWIG_IsOK(res1)) {
27697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27698 }
27699 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27701 if (!SWIG_IsOK(res2)) {
27702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27703 }
27704 if (!argp2) {
27705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27706 }
27707 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 {
27711 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27712 result = (wxTimeSpan *) &_result_ref;
27713 }
27714 wxPyEndAllowThreads(__tstate);
27715 if (PyErr_Occurred()) SWIG_fail;
27716 }
27717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27725 PyObject *resultobj = 0;
27726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27727 int arg2 ;
27728 wxTimeSpan *result = 0 ;
27729 void *argp1 = 0 ;
27730 int res1 = 0 ;
27731 int val2 ;
27732 int ecode2 = 0 ;
27733 PyObject * obj0 = 0 ;
27734 PyObject * obj1 = 0 ;
27735 char * kwnames[] = {
27736 (char *) "self",(char *) "n", NULL
27737 };
27738
27739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27743 }
27744 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27745 ecode2 = SWIG_AsVal_int(obj1, &val2);
27746 if (!SWIG_IsOK(ecode2)) {
27747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27748 }
27749 arg2 = static_cast< int >(val2);
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 {
27753 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27754 result = (wxTimeSpan *) &_result_ref;
27755 }
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27760 return resultobj;
27761 fail:
27762 return NULL;
27763 }
27764
27765
27766 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27767 PyObject *resultobj = 0;
27768 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27769 wxTimeSpan *result = 0 ;
27770 void *argp1 = 0 ;
27771 int res1 = 0 ;
27772 PyObject *swig_obj[1] ;
27773
27774 if (!args) SWIG_fail;
27775 swig_obj[0] = args;
27776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27779 }
27780 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 {
27784 wxTimeSpan &_result_ref = (arg1)->Neg();
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_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27798 PyObject *resultobj = 0;
27799 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27800 wxTimeSpan result;
27801 void *argp1 = 0 ;
27802 int res1 = 0 ;
27803 PyObject *swig_obj[1] ;
27804
27805 if (!args) SWIG_fail;
27806 swig_obj[0] = args;
27807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27808 if (!SWIG_IsOK(res1)) {
27809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27810 }
27811 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 result = ((wxTimeSpan const *)arg1)->Abs();
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27826 PyObject *resultobj = 0;
27827 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27828 wxTimeSpan *arg2 = 0 ;
27829 wxTimeSpan *result = 0 ;
27830 void *argp1 = 0 ;
27831 int res1 = 0 ;
27832 void *argp2 = 0 ;
27833 int res2 = 0 ;
27834 PyObject * obj0 = 0 ;
27835 PyObject * obj1 = 0 ;
27836 char * kwnames[] = {
27837 (char *) "self",(char *) "diff", NULL
27838 };
27839
27840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27842 if (!SWIG_IsOK(res1)) {
27843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27844 }
27845 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27847 if (!SWIG_IsOK(res2)) {
27848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27849 }
27850 if (!argp2) {
27851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27852 }
27853 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 {
27857 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
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, SWIG_POINTER_OWN | 0 );
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27871 PyObject *resultobj = 0;
27872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27873 wxTimeSpan *arg2 = 0 ;
27874 wxTimeSpan *result = 0 ;
27875 void *argp1 = 0 ;
27876 int res1 = 0 ;
27877 void *argp2 = 0 ;
27878 int res2 = 0 ;
27879 PyObject * obj0 = 0 ;
27880 PyObject * obj1 = 0 ;
27881 char * kwnames[] = {
27882 (char *) "self",(char *) "diff", NULL
27883 };
27884
27885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27887 if (!SWIG_IsOK(res1)) {
27888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27889 }
27890 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27891 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27892 if (!SWIG_IsOK(res2)) {
27893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27894 }
27895 if (!argp2) {
27896 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27897 }
27898 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 {
27902 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27903 result = (wxTimeSpan *) &_result_ref;
27904 }
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj = 0;
27917 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27918 int arg2 ;
27919 wxTimeSpan *result = 0 ;
27920 void *argp1 = 0 ;
27921 int res1 = 0 ;
27922 int val2 ;
27923 int ecode2 = 0 ;
27924 PyObject * obj0 = 0 ;
27925 PyObject * obj1 = 0 ;
27926 char * kwnames[] = {
27927 (char *) "self",(char *) "n", NULL
27928 };
27929
27930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27932 if (!SWIG_IsOK(res1)) {
27933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27934 }
27935 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27936 ecode2 = SWIG_AsVal_int(obj1, &val2);
27937 if (!SWIG_IsOK(ecode2)) {
27938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27939 }
27940 arg2 = static_cast< int >(val2);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 {
27944 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27945 result = (wxTimeSpan *) &_result_ref;
27946 }
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27958 PyObject *resultobj = 0;
27959 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27960 wxTimeSpan *result = 0 ;
27961 void *argp1 = 0 ;
27962 int res1 = 0 ;
27963 PyObject *swig_obj[1] ;
27964
27965 if (!args) SWIG_fail;
27966 swig_obj[0] = args;
27967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27968 if (!SWIG_IsOK(res1)) {
27969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27970 }
27971 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 {
27975 wxTimeSpan &_result_ref = (arg1)->operator -();
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, 0 | 0 );
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj = 0;
27990 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27991 wxTimeSpan *arg2 = 0 ;
27992 wxTimeSpan result;
27993 void *argp1 = 0 ;
27994 int res1 = 0 ;
27995 void *argp2 = 0 ;
27996 int res2 = 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char * kwnames[] = {
28000 (char *) "self",(char *) "other", NULL
28001 };
28002
28003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28005 if (!SWIG_IsOK(res1)) {
28006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28007 }
28008 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28010 if (!SWIG_IsOK(res2)) {
28011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28012 }
28013 if (!argp2) {
28014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28015 }
28016 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = 0;
28032 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28033 wxTimeSpan *arg2 = 0 ;
28034 wxTimeSpan result;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 void *argp2 = 0 ;
28038 int res2 = 0 ;
28039 PyObject * obj0 = 0 ;
28040 PyObject * obj1 = 0 ;
28041 char * kwnames[] = {
28042 (char *) "self",(char *) "other", NULL
28043 };
28044
28045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28047 if (!SWIG_IsOK(res1)) {
28048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28049 }
28050 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28052 if (!SWIG_IsOK(res2)) {
28053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28054 }
28055 if (!argp2) {
28056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28057 }
28058 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj = 0;
28074 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28075 int arg2 ;
28076 wxTimeSpan result;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 int val2 ;
28080 int ecode2 = 0 ;
28081 PyObject * obj0 = 0 ;
28082 PyObject * obj1 = 0 ;
28083 char * kwnames[] = {
28084 (char *) "self",(char *) "n", NULL
28085 };
28086
28087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28089 if (!SWIG_IsOK(res1)) {
28090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28091 }
28092 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28093 ecode2 = SWIG_AsVal_int(obj1, &val2);
28094 if (!SWIG_IsOK(ecode2)) {
28095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28096 }
28097 arg2 = static_cast< int >(val2);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = wxTimeSpan___mul__(arg1,arg2);
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj = 0;
28113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28114 int arg2 ;
28115 wxTimeSpan result;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 int val2 ;
28119 int ecode2 = 0 ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "self",(char *) "n", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28128 if (!SWIG_IsOK(res1)) {
28129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28130 }
28131 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28132 ecode2 = SWIG_AsVal_int(obj1, &val2);
28133 if (!SWIG_IsOK(ecode2)) {
28134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28135 }
28136 arg2 = static_cast< int >(val2);
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = wxTimeSpan___rmul__(arg1,arg2);
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj = 0;
28152 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28153 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28154 bool result;
28155 void *argp1 = 0 ;
28156 int res1 = 0 ;
28157 void *argp2 = 0 ;
28158 int res2 = 0 ;
28159 PyObject * obj0 = 0 ;
28160 PyObject * obj1 = 0 ;
28161 char * kwnames[] = {
28162 (char *) "self",(char *) "other", NULL
28163 };
28164
28165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28167 if (!SWIG_IsOK(res1)) {
28168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28169 }
28170 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28172 if (!SWIG_IsOK(res2)) {
28173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28174 }
28175 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28176 {
28177 PyThreadState* __tstate = wxPyBeginAllowThreads();
28178 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 {
28183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28184 }
28185 return resultobj;
28186 fail:
28187 return NULL;
28188 }
28189
28190
28191 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj = 0;
28193 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28194 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28195 bool result;
28196 void *argp1 = 0 ;
28197 int res1 = 0 ;
28198 void *argp2 = 0 ;
28199 int res2 = 0 ;
28200 PyObject * obj0 = 0 ;
28201 PyObject * obj1 = 0 ;
28202 char * kwnames[] = {
28203 (char *) "self",(char *) "other", NULL
28204 };
28205
28206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28208 if (!SWIG_IsOK(res1)) {
28209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28210 }
28211 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28213 if (!SWIG_IsOK(res2)) {
28214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28215 }
28216 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28220 wxPyEndAllowThreads(__tstate);
28221 if (PyErr_Occurred()) SWIG_fail;
28222 }
28223 {
28224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28225 }
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj = 0;
28234 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28235 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28236 bool result;
28237 void *argp1 = 0 ;
28238 int res1 = 0 ;
28239 void *argp2 = 0 ;
28240 int res2 = 0 ;
28241 PyObject * obj0 = 0 ;
28242 PyObject * obj1 = 0 ;
28243 char * kwnames[] = {
28244 (char *) "self",(char *) "other", NULL
28245 };
28246
28247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28249 if (!SWIG_IsOK(res1)) {
28250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28251 }
28252 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28254 if (!SWIG_IsOK(res2)) {
28255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28256 }
28257 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 {
28265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28266 }
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28274 PyObject *resultobj = 0;
28275 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28276 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28277 bool result;
28278 void *argp1 = 0 ;
28279 int res1 = 0 ;
28280 void *argp2 = 0 ;
28281 int res2 = 0 ;
28282 PyObject * obj0 = 0 ;
28283 PyObject * obj1 = 0 ;
28284 char * kwnames[] = {
28285 (char *) "self",(char *) "other", NULL
28286 };
28287
28288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28290 if (!SWIG_IsOK(res1)) {
28291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28292 }
28293 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28295 if (!SWIG_IsOK(res2)) {
28296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28297 }
28298 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 {
28306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28307 }
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28315 PyObject *resultobj = 0;
28316 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28317 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28318 bool result;
28319 void *argp1 = 0 ;
28320 int res1 = 0 ;
28321 void *argp2 = 0 ;
28322 int res2 = 0 ;
28323 PyObject * obj0 = 0 ;
28324 PyObject * obj1 = 0 ;
28325 char * kwnames[] = {
28326 (char *) "self",(char *) "other", NULL
28327 };
28328
28329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28331 if (!SWIG_IsOK(res1)) {
28332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28333 }
28334 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28336 if (!SWIG_IsOK(res2)) {
28337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28338 }
28339 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj = 0;
28357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28358 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28359 bool result;
28360 void *argp1 = 0 ;
28361 int res1 = 0 ;
28362 void *argp2 = 0 ;
28363 int res2 = 0 ;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char * kwnames[] = {
28367 (char *) "self",(char *) "other", NULL
28368 };
28369
28370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28372 if (!SWIG_IsOK(res1)) {
28373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28374 }
28375 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28377 if (!SWIG_IsOK(res2)) {
28378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28379 }
28380 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 {
28388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28389 }
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28397 PyObject *resultobj = 0;
28398 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28399 bool result;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 PyObject *swig_obj[1] ;
28403
28404 if (!args) SWIG_fail;
28405 swig_obj[0] = args;
28406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28407 if (!SWIG_IsOK(res1)) {
28408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28409 }
28410 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 {
28418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28419 }
28420 return resultobj;
28421 fail:
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427 PyObject *resultobj = 0;
28428 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28429 bool result;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 PyObject *swig_obj[1] ;
28433
28434 if (!args) SWIG_fail;
28435 swig_obj[0] = args;
28436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28437 if (!SWIG_IsOK(res1)) {
28438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28439 }
28440 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28441 {
28442 PyThreadState* __tstate = wxPyBeginAllowThreads();
28443 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28444 wxPyEndAllowThreads(__tstate);
28445 if (PyErr_Occurred()) SWIG_fail;
28446 }
28447 {
28448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28449 }
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28457 PyObject *resultobj = 0;
28458 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28459 bool result;
28460 void *argp1 = 0 ;
28461 int res1 = 0 ;
28462 PyObject *swig_obj[1] ;
28463
28464 if (!args) SWIG_fail;
28465 swig_obj[0] = args;
28466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28467 if (!SWIG_IsOK(res1)) {
28468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28469 }
28470 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj = 0;
28488 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28489 wxTimeSpan *arg2 = 0 ;
28490 bool result;
28491 void *argp1 = 0 ;
28492 int res1 = 0 ;
28493 void *argp2 = 0 ;
28494 int res2 = 0 ;
28495 PyObject * obj0 = 0 ;
28496 PyObject * obj1 = 0 ;
28497 char * kwnames[] = {
28498 (char *) "self",(char *) "ts", NULL
28499 };
28500
28501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28503 if (!SWIG_IsOK(res1)) {
28504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28505 }
28506 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28508 if (!SWIG_IsOK(res2)) {
28509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28510 }
28511 if (!argp2) {
28512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28513 }
28514 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 {
28522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28523 }
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj = 0;
28532 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28533 wxTimeSpan *arg2 = 0 ;
28534 bool result;
28535 void *argp1 = 0 ;
28536 int res1 = 0 ;
28537 void *argp2 = 0 ;
28538 int res2 = 0 ;
28539 PyObject * obj0 = 0 ;
28540 PyObject * obj1 = 0 ;
28541 char * kwnames[] = {
28542 (char *) "self",(char *) "ts", NULL
28543 };
28544
28545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28547 if (!SWIG_IsOK(res1)) {
28548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28549 }
28550 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28552 if (!SWIG_IsOK(res2)) {
28553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28554 }
28555 if (!argp2) {
28556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28557 }
28558 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 {
28566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28567 }
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28575 PyObject *resultobj = 0;
28576 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28577 wxTimeSpan *arg2 = 0 ;
28578 bool result;
28579 void *argp1 = 0 ;
28580 int res1 = 0 ;
28581 void *argp2 = 0 ;
28582 int res2 = 0 ;
28583 PyObject * obj0 = 0 ;
28584 PyObject * obj1 = 0 ;
28585 char * kwnames[] = {
28586 (char *) "self",(char *) "t", NULL
28587 };
28588
28589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28591 if (!SWIG_IsOK(res1)) {
28592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28593 }
28594 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28596 if (!SWIG_IsOK(res2)) {
28597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28598 }
28599 if (!argp2) {
28600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28601 }
28602 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *resultobj = 0;
28620 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28621 int result;
28622 void *argp1 = 0 ;
28623 int res1 = 0 ;
28624 PyObject *swig_obj[1] ;
28625
28626 if (!args) SWIG_fail;
28627 swig_obj[0] = args;
28628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28629 if (!SWIG_IsOK(res1)) {
28630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28631 }
28632 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 resultobj = SWIG_From_int(static_cast< int >(result));
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28649 int result;
28650 void *argp1 = 0 ;
28651 int res1 = 0 ;
28652 PyObject *swig_obj[1] ;
28653
28654 if (!args) SWIG_fail;
28655 swig_obj[0] = args;
28656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28657 if (!SWIG_IsOK(res1)) {
28658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28659 }
28660 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 resultobj = SWIG_From_int(static_cast< int >(result));
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 PyObject *resultobj = 0;
28676 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28677 int result;
28678 void *argp1 = 0 ;
28679 int res1 = 0 ;
28680 PyObject *swig_obj[1] ;
28681
28682 if (!args) SWIG_fail;
28683 swig_obj[0] = args;
28684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28685 if (!SWIG_IsOK(res1)) {
28686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28687 }
28688 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 resultobj = SWIG_From_int(static_cast< int >(result));
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28703 PyObject *resultobj = 0;
28704 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28705 int result;
28706 void *argp1 = 0 ;
28707 int res1 = 0 ;
28708 PyObject *swig_obj[1] ;
28709
28710 if (!args) SWIG_fail;
28711 swig_obj[0] = args;
28712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28713 if (!SWIG_IsOK(res1)) {
28714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28715 }
28716 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_From_int(static_cast< int >(result));
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *resultobj = 0;
28732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28733 wxLongLong result;
28734 void *argp1 = 0 ;
28735 int res1 = 0 ;
28736 PyObject *swig_obj[1] ;
28737
28738 if (!args) SWIG_fail;
28739 swig_obj[0] = args;
28740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28741 if (!SWIG_IsOK(res1)) {
28742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28743 }
28744 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 {
28752 PyObject *hi, *lo, *shifter, *shifted;
28753 hi = PyLong_FromLong( (&result)->GetHi() );
28754 lo = PyLong_FromLong( (&result)->GetLo() );
28755 shifter = PyLong_FromLong(32);
28756 shifted = PyNumber_Lshift(hi, shifter);
28757 resultobj = PyNumber_Or(shifted, lo);
28758 Py_DECREF(hi);
28759 Py_DECREF(lo);
28760 Py_DECREF(shifter);
28761 Py_DECREF(shifted);
28762 }
28763 return resultobj;
28764 fail:
28765 return NULL;
28766 }
28767
28768
28769 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28770 PyObject *resultobj = 0;
28771 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28772 wxLongLong result;
28773 void *argp1 = 0 ;
28774 int res1 = 0 ;
28775 PyObject *swig_obj[1] ;
28776
28777 if (!args) SWIG_fail;
28778 swig_obj[0] = args;
28779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28780 if (!SWIG_IsOK(res1)) {
28781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28782 }
28783 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 {
28791 PyObject *hi, *lo, *shifter, *shifted;
28792 hi = PyLong_FromLong( (&result)->GetHi() );
28793 lo = PyLong_FromLong( (&result)->GetLo() );
28794 shifter = PyLong_FromLong(32);
28795 shifted = PyNumber_Lshift(hi, shifter);
28796 resultobj = PyNumber_Or(shifted, lo);
28797 Py_DECREF(hi);
28798 Py_DECREF(lo);
28799 Py_DECREF(shifter);
28800 Py_DECREF(shifted);
28801 }
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28809 PyObject *resultobj = 0;
28810 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28811 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28812 wxString *arg2 = (wxString *) &arg2_defvalue ;
28813 wxString result;
28814 void *argp1 = 0 ;
28815 int res1 = 0 ;
28816 bool temp2 = false ;
28817 PyObject * obj0 = 0 ;
28818 PyObject * obj1 = 0 ;
28819 char * kwnames[] = {
28820 (char *) "self",(char *) "format", NULL
28821 };
28822
28823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28825 if (!SWIG_IsOK(res1)) {
28826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28827 }
28828 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28829 if (obj1) {
28830 {
28831 arg2 = wxString_in_helper(obj1);
28832 if (arg2 == NULL) SWIG_fail;
28833 temp2 = true;
28834 }
28835 }
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 {
28843 #if wxUSE_UNICODE
28844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28845 #else
28846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28847 #endif
28848 }
28849 {
28850 if (temp2)
28851 delete arg2;
28852 }
28853 return resultobj;
28854 fail:
28855 {
28856 if (temp2)
28857 delete arg2;
28858 }
28859 return NULL;
28860 }
28861
28862
28863 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28864 PyObject *obj;
28865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28866 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28867 return SWIG_Py_Void();
28868 }
28869
28870 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28871 return SWIG_Python_InitShadowInstance(args);
28872 }
28873
28874 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj = 0;
28876 int arg1 = (int) 0 ;
28877 int arg2 = (int) 0 ;
28878 int arg3 = (int) 0 ;
28879 int arg4 = (int) 0 ;
28880 wxDateSpan *result = 0 ;
28881 int val1 ;
28882 int ecode1 = 0 ;
28883 int val2 ;
28884 int ecode2 = 0 ;
28885 int val3 ;
28886 int ecode3 = 0 ;
28887 int val4 ;
28888 int ecode4 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 PyObject * obj2 = 0 ;
28892 PyObject * obj3 = 0 ;
28893 char * kwnames[] = {
28894 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28895 };
28896
28897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28898 if (obj0) {
28899 ecode1 = SWIG_AsVal_int(obj0, &val1);
28900 if (!SWIG_IsOK(ecode1)) {
28901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28902 }
28903 arg1 = static_cast< int >(val1);
28904 }
28905 if (obj1) {
28906 ecode2 = SWIG_AsVal_int(obj1, &val2);
28907 if (!SWIG_IsOK(ecode2)) {
28908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28909 }
28910 arg2 = static_cast< int >(val2);
28911 }
28912 if (obj2) {
28913 ecode3 = SWIG_AsVal_int(obj2, &val3);
28914 if (!SWIG_IsOK(ecode3)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28916 }
28917 arg3 = static_cast< int >(val3);
28918 }
28919 if (obj3) {
28920 ecode4 = SWIG_AsVal_int(obj3, &val4);
28921 if (!SWIG_IsOK(ecode4)) {
28922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28923 }
28924 arg4 = static_cast< int >(val4);
28925 }
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28942 void *argp1 = 0 ;
28943 int res1 = 0 ;
28944 PyObject *swig_obj[1] ;
28945
28946 if (!args) SWIG_fail;
28947 swig_obj[0] = args;
28948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28949 if (!SWIG_IsOK(res1)) {
28950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28951 }
28952 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 delete arg1;
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_Py_Void();
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj = 0;
28969 int arg1 ;
28970 wxDateSpan result;
28971 int val1 ;
28972 int ecode1 = 0 ;
28973 PyObject * obj0 = 0 ;
28974 char * kwnames[] = {
28975 (char *) "days", NULL
28976 };
28977
28978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
28979 ecode1 = SWIG_AsVal_int(obj0, &val1);
28980 if (!SWIG_IsOK(ecode1)) {
28981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
28982 }
28983 arg1 = static_cast< int >(val1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = wxDateSpan::Days(arg1);
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxDateSpan result;
29000
29001 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = wxDateSpan::Day();
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj = 0;
29017 int arg1 ;
29018 wxDateSpan result;
29019 int val1 ;
29020 int ecode1 = 0 ;
29021 PyObject * obj0 = 0 ;
29022 char * kwnames[] = {
29023 (char *) "weeks", NULL
29024 };
29025
29026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29027 ecode1 = SWIG_AsVal_int(obj0, &val1);
29028 if (!SWIG_IsOK(ecode1)) {
29029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29030 }
29031 arg1 = static_cast< int >(val1);
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = wxDateSpan::Weeks(arg1);
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29046 PyObject *resultobj = 0;
29047 wxDateSpan result;
29048
29049 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = wxDateSpan::Week();
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj = 0;
29065 int arg1 ;
29066 wxDateSpan result;
29067 int val1 ;
29068 int ecode1 = 0 ;
29069 PyObject * obj0 = 0 ;
29070 char * kwnames[] = {
29071 (char *) "mon", NULL
29072 };
29073
29074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29075 ecode1 = SWIG_AsVal_int(obj0, &val1);
29076 if (!SWIG_IsOK(ecode1)) {
29077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29078 }
29079 arg1 = static_cast< int >(val1);
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = wxDateSpan::Months(arg1);
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29094 PyObject *resultobj = 0;
29095 wxDateSpan result;
29096
29097 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = wxDateSpan::Month();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj = 0;
29113 int arg1 ;
29114 wxDateSpan result;
29115 int val1 ;
29116 int ecode1 = 0 ;
29117 PyObject * obj0 = 0 ;
29118 char * kwnames[] = {
29119 (char *) "years", NULL
29120 };
29121
29122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29123 ecode1 = SWIG_AsVal_int(obj0, &val1);
29124 if (!SWIG_IsOK(ecode1)) {
29125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29126 }
29127 arg1 = static_cast< int >(val1);
29128 {
29129 PyThreadState* __tstate = wxPyBeginAllowThreads();
29130 result = wxDateSpan::Years(arg1);
29131 wxPyEndAllowThreads(__tstate);
29132 if (PyErr_Occurred()) SWIG_fail;
29133 }
29134 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29135 return resultobj;
29136 fail:
29137 return NULL;
29138 }
29139
29140
29141 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142 PyObject *resultobj = 0;
29143 wxDateSpan result;
29144
29145 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29146 {
29147 PyThreadState* __tstate = wxPyBeginAllowThreads();
29148 result = wxDateSpan::Year();
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29160 PyObject *resultobj = 0;
29161 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29162 int arg2 ;
29163 wxDateSpan *result = 0 ;
29164 void *argp1 = 0 ;
29165 int res1 = 0 ;
29166 int val2 ;
29167 int ecode2 = 0 ;
29168 PyObject * obj0 = 0 ;
29169 PyObject * obj1 = 0 ;
29170 char * kwnames[] = {
29171 (char *) "self",(char *) "n", NULL
29172 };
29173
29174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29176 if (!SWIG_IsOK(res1)) {
29177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29178 }
29179 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29180 ecode2 = SWIG_AsVal_int(obj1, &val2);
29181 if (!SWIG_IsOK(ecode2)) {
29182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29183 }
29184 arg2 = static_cast< int >(val2);
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 {
29188 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29189 result = (wxDateSpan *) &_result_ref;
29190 }
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29202 PyObject *resultobj = 0;
29203 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29204 int arg2 ;
29205 wxDateSpan *result = 0 ;
29206 void *argp1 = 0 ;
29207 int res1 = 0 ;
29208 int val2 ;
29209 int ecode2 = 0 ;
29210 PyObject * obj0 = 0 ;
29211 PyObject * obj1 = 0 ;
29212 char * kwnames[] = {
29213 (char *) "self",(char *) "n", NULL
29214 };
29215
29216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29218 if (!SWIG_IsOK(res1)) {
29219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29220 }
29221 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29222 ecode2 = SWIG_AsVal_int(obj1, &val2);
29223 if (!SWIG_IsOK(ecode2)) {
29224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29225 }
29226 arg2 = static_cast< int >(val2);
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 {
29230 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29231 result = (wxDateSpan *) &_result_ref;
29232 }
29233 wxPyEndAllowThreads(__tstate);
29234 if (PyErr_Occurred()) SWIG_fail;
29235 }
29236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29237 return resultobj;
29238 fail:
29239 return NULL;
29240 }
29241
29242
29243 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29244 PyObject *resultobj = 0;
29245 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29246 int arg2 ;
29247 wxDateSpan *result = 0 ;
29248 void *argp1 = 0 ;
29249 int res1 = 0 ;
29250 int val2 ;
29251 int ecode2 = 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 char * kwnames[] = {
29255 (char *) "self",(char *) "n", NULL
29256 };
29257
29258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29260 if (!SWIG_IsOK(res1)) {
29261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29262 }
29263 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29264 ecode2 = SWIG_AsVal_int(obj1, &val2);
29265 if (!SWIG_IsOK(ecode2)) {
29266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29267 }
29268 arg2 = static_cast< int >(val2);
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 {
29272 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29273 result = (wxDateSpan *) &_result_ref;
29274 }
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29286 PyObject *resultobj = 0;
29287 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29288 int arg2 ;
29289 wxDateSpan *result = 0 ;
29290 void *argp1 = 0 ;
29291 int res1 = 0 ;
29292 int val2 ;
29293 int ecode2 = 0 ;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 char * kwnames[] = {
29297 (char *) "self",(char *) "n", NULL
29298 };
29299
29300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29302 if (!SWIG_IsOK(res1)) {
29303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29304 }
29305 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29306 ecode2 = SWIG_AsVal_int(obj1, &val2);
29307 if (!SWIG_IsOK(ecode2)) {
29308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29309 }
29310 arg2 = static_cast< int >(val2);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 {
29314 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29315 result = (wxDateSpan *) &_result_ref;
29316 }
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29328 PyObject *resultobj = 0;
29329 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29330 int result;
29331 void *argp1 = 0 ;
29332 int res1 = 0 ;
29333 PyObject *swig_obj[1] ;
29334
29335 if (!args) SWIG_fail;
29336 swig_obj[0] = args;
29337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29338 if (!SWIG_IsOK(res1)) {
29339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29340 }
29341 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = (int)((wxDateSpan const *)arg1)->GetYears();
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_From_int(static_cast< int >(result));
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29356 PyObject *resultobj = 0;
29357 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29358 int result;
29359 void *argp1 = 0 ;
29360 int res1 = 0 ;
29361 PyObject *swig_obj[1] ;
29362
29363 if (!args) SWIG_fail;
29364 swig_obj[0] = args;
29365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29366 if (!SWIG_IsOK(res1)) {
29367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29368 }
29369 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_From_int(static_cast< int >(result));
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 PyObject *resultobj = 0;
29385 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29386 int result;
29387 void *argp1 = 0 ;
29388 int res1 = 0 ;
29389 PyObject *swig_obj[1] ;
29390
29391 if (!args) SWIG_fail;
29392 swig_obj[0] = args;
29393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29396 }
29397 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_From_int(static_cast< int >(result));
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29412 PyObject *resultobj = 0;
29413 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29414 int result;
29415 void *argp1 = 0 ;
29416 int res1 = 0 ;
29417 PyObject *swig_obj[1] ;
29418
29419 if (!args) SWIG_fail;
29420 swig_obj[0] = args;
29421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29422 if (!SWIG_IsOK(res1)) {
29423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29424 }
29425 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (int)((wxDateSpan const *)arg1)->GetDays();
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 resultobj = SWIG_From_int(static_cast< int >(result));
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29440 PyObject *resultobj = 0;
29441 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29442 int result;
29443 void *argp1 = 0 ;
29444 int res1 = 0 ;
29445 PyObject *swig_obj[1] ;
29446
29447 if (!args) SWIG_fail;
29448 swig_obj[0] = args;
29449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29450 if (!SWIG_IsOK(res1)) {
29451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29452 }
29453 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29457 wxPyEndAllowThreads(__tstate);
29458 if (PyErr_Occurred()) SWIG_fail;
29459 }
29460 resultobj = SWIG_From_int(static_cast< int >(result));
29461 return resultobj;
29462 fail:
29463 return NULL;
29464 }
29465
29466
29467 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29468 PyObject *resultobj = 0;
29469 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29470 wxDateSpan *arg2 = 0 ;
29471 wxDateSpan *result = 0 ;
29472 void *argp1 = 0 ;
29473 int res1 = 0 ;
29474 void *argp2 = 0 ;
29475 int res2 = 0 ;
29476 PyObject * obj0 = 0 ;
29477 PyObject * obj1 = 0 ;
29478 char * kwnames[] = {
29479 (char *) "self",(char *) "other", NULL
29480 };
29481
29482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29486 }
29487 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29488 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29489 if (!SWIG_IsOK(res2)) {
29490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29491 }
29492 if (!argp2) {
29493 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29494 }
29495 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 {
29499 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29500 result = (wxDateSpan *) &_result_ref;
29501 }
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj = 0;
29514 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29515 wxDateSpan *arg2 = 0 ;
29516 wxDateSpan *result = 0 ;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 void *argp2 = 0 ;
29520 int res2 = 0 ;
29521 PyObject * obj0 = 0 ;
29522 PyObject * obj1 = 0 ;
29523 char * kwnames[] = {
29524 (char *) "self",(char *) "other", NULL
29525 };
29526
29527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29529 if (!SWIG_IsOK(res1)) {
29530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29531 }
29532 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29534 if (!SWIG_IsOK(res2)) {
29535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29536 }
29537 if (!argp2) {
29538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29539 }
29540 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 {
29544 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29545 result = (wxDateSpan *) &_result_ref;
29546 }
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29551 return resultobj;
29552 fail:
29553 return NULL;
29554 }
29555
29556
29557 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29558 PyObject *resultobj = 0;
29559 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29560 wxDateSpan *result = 0 ;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 PyObject *swig_obj[1] ;
29564
29565 if (!args) SWIG_fail;
29566 swig_obj[0] = args;
29567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29570 }
29571 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 {
29575 wxDateSpan &_result_ref = (arg1)->Neg();
29576 result = (wxDateSpan *) &_result_ref;
29577 }
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29591 int arg2 ;
29592 wxDateSpan *result = 0 ;
29593 void *argp1 = 0 ;
29594 int res1 = 0 ;
29595 int val2 ;
29596 int ecode2 = 0 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char * kwnames[] = {
29600 (char *) "self",(char *) "factor", NULL
29601 };
29602
29603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29605 if (!SWIG_IsOK(res1)) {
29606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29607 }
29608 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29609 ecode2 = SWIG_AsVal_int(obj1, &val2);
29610 if (!SWIG_IsOK(ecode2)) {
29611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29612 }
29613 arg2 = static_cast< int >(val2);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 {
29617 wxDateSpan &_result_ref = (arg1)->Multiply(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___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj = 0;
29632 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29633 wxDateSpan *arg2 = 0 ;
29634 wxDateSpan *result = 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 void *argp2 = 0 ;
29638 int res2 = 0 ;
29639 PyObject * obj0 = 0 ;
29640 PyObject * obj1 = 0 ;
29641 char * kwnames[] = {
29642 (char *) "self",(char *) "other", NULL
29643 };
29644
29645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29649 }
29650 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29652 if (!SWIG_IsOK(res2)) {
29653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29654 }
29655 if (!argp2) {
29656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29657 }
29658 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29659 {
29660 PyThreadState* __tstate = wxPyBeginAllowThreads();
29661 {
29662 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29663 result = (wxDateSpan *) &_result_ref;
29664 }
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj = 0;
29677 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29678 wxDateSpan *arg2 = 0 ;
29679 wxDateSpan *result = 0 ;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 void *argp2 = 0 ;
29683 int res2 = 0 ;
29684 PyObject * obj0 = 0 ;
29685 PyObject * obj1 = 0 ;
29686 char * kwnames[] = {
29687 (char *) "self",(char *) "other", NULL
29688 };
29689
29690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29694 }
29695 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29696 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29697 if (!SWIG_IsOK(res2)) {
29698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29699 }
29700 if (!argp2) {
29701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29702 }
29703 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 {
29707 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29708 result = (wxDateSpan *) &_result_ref;
29709 }
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *resultobj = 0;
29722 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29723 wxDateSpan *result = 0 ;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 PyObject *swig_obj[1] ;
29727
29728 if (!args) SWIG_fail;
29729 swig_obj[0] = args;
29730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29731 if (!SWIG_IsOK(res1)) {
29732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29733 }
29734 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 {
29738 wxDateSpan &_result_ref = (arg1)->operator -();
29739 result = (wxDateSpan *) &_result_ref;
29740 }
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj = 0;
29753 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29754 int arg2 ;
29755 wxDateSpan *result = 0 ;
29756 void *argp1 = 0 ;
29757 int res1 = 0 ;
29758 int val2 ;
29759 int ecode2 = 0 ;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char * kwnames[] = {
29763 (char *) "self",(char *) "factor", NULL
29764 };
29765
29766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29770 }
29771 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29772 ecode2 = SWIG_AsVal_int(obj1, &val2);
29773 if (!SWIG_IsOK(ecode2)) {
29774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29775 }
29776 arg2 = static_cast< int >(val2);
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 {
29780 wxDateSpan &_result_ref = (arg1)->operator *=(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___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29794 PyObject *resultobj = 0;
29795 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29796 wxDateSpan *arg2 = 0 ;
29797 wxDateSpan result;
29798 void *argp1 = 0 ;
29799 int res1 = 0 ;
29800 void *argp2 = 0 ;
29801 int res2 = 0 ;
29802 PyObject * obj0 = 0 ;
29803 PyObject * obj1 = 0 ;
29804 char * kwnames[] = {
29805 (char *) "self",(char *) "other", NULL
29806 };
29807
29808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29810 if (!SWIG_IsOK(res1)) {
29811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29812 }
29813 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29814 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29815 if (!SWIG_IsOK(res2)) {
29816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29817 }
29818 if (!argp2) {
29819 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29820 }
29821 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj = 0;
29837 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29838 wxDateSpan *arg2 = 0 ;
29839 wxDateSpan result;
29840 void *argp1 = 0 ;
29841 int res1 = 0 ;
29842 void *argp2 = 0 ;
29843 int res2 = 0 ;
29844 PyObject * obj0 = 0 ;
29845 PyObject * obj1 = 0 ;
29846 char * kwnames[] = {
29847 (char *) "self",(char *) "other", NULL
29848 };
29849
29850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29852 if (!SWIG_IsOK(res1)) {
29853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29854 }
29855 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29857 if (!SWIG_IsOK(res2)) {
29858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29859 }
29860 if (!argp2) {
29861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29862 }
29863 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29871 return resultobj;
29872 fail:
29873 return NULL;
29874 }
29875
29876
29877 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29878 PyObject *resultobj = 0;
29879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29880 int arg2 ;
29881 wxDateSpan result;
29882 void *argp1 = 0 ;
29883 int res1 = 0 ;
29884 int val2 ;
29885 int ecode2 = 0 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "self",(char *) "n", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29896 }
29897 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29898 ecode2 = SWIG_AsVal_int(obj1, &val2);
29899 if (!SWIG_IsOK(ecode2)) {
29900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29901 }
29902 arg2 = static_cast< int >(val2);
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 result = wxDateSpan___mul__(arg1,arg2);
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj = 0;
29918 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29919 int arg2 ;
29920 wxDateSpan result;
29921 void *argp1 = 0 ;
29922 int res1 = 0 ;
29923 int val2 ;
29924 int ecode2 = 0 ;
29925 PyObject * obj0 = 0 ;
29926 PyObject * obj1 = 0 ;
29927 char * kwnames[] = {
29928 (char *) "self",(char *) "n", NULL
29929 };
29930
29931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29933 if (!SWIG_IsOK(res1)) {
29934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29935 }
29936 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29937 ecode2 = SWIG_AsVal_int(obj1, &val2);
29938 if (!SWIG_IsOK(ecode2)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29940 }
29941 arg2 = static_cast< int >(val2);
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = wxDateSpan___rmul__(arg1,arg2);
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29958 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
29959 bool result;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 void *argp2 = 0 ;
29963 int res2 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 char * kwnames[] = {
29967 (char *) "self",(char *) "other", NULL
29968 };
29969
29970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29972 if (!SWIG_IsOK(res1)) {
29973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29974 }
29975 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29977 if (!SWIG_IsOK(res2)) {
29978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
29979 }
29980 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
29984 wxPyEndAllowThreads(__tstate);
29985 if (PyErr_Occurred()) SWIG_fail;
29986 }
29987 {
29988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29989 }
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj = 0;
29998 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29999 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30000 bool result;
30001 void *argp1 = 0 ;
30002 int res1 = 0 ;
30003 void *argp2 = 0 ;
30004 int res2 = 0 ;
30005 PyObject * obj0 = 0 ;
30006 PyObject * obj1 = 0 ;
30007 char * kwnames[] = {
30008 (char *) "self",(char *) "other", NULL
30009 };
30010
30011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30013 if (!SWIG_IsOK(res1)) {
30014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30015 }
30016 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30018 if (!SWIG_IsOK(res2)) {
30019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30020 }
30021 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30025 wxPyEndAllowThreads(__tstate);
30026 if (PyErr_Occurred()) SWIG_fail;
30027 }
30028 {
30029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30030 }
30031 return resultobj;
30032 fail:
30033 return NULL;
30034 }
30035
30036
30037 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30038 PyObject *obj;
30039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30040 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30041 return SWIG_Py_Void();
30042 }
30043
30044 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30045 return SWIG_Python_InitShadowInstance(args);
30046 }
30047
30048 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30049 PyObject *resultobj = 0;
30050 long result;
30051
30052 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30053 {
30054 PyThreadState* __tstate = wxPyBeginAllowThreads();
30055 result = (long)wxGetLocalTime();
30056 wxPyEndAllowThreads(__tstate);
30057 if (PyErr_Occurred()) SWIG_fail;
30058 }
30059 resultobj = SWIG_From_long(static_cast< long >(result));
30060 return resultobj;
30061 fail:
30062 return NULL;
30063 }
30064
30065
30066 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30067 PyObject *resultobj = 0;
30068 long result;
30069
30070 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (long)wxGetUTCTime();
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 resultobj = SWIG_From_long(static_cast< long >(result));
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 long result;
30087
30088 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30089 {
30090 PyThreadState* __tstate = wxPyBeginAllowThreads();
30091 result = (long)wxGetCurrentTime();
30092 wxPyEndAllowThreads(__tstate);
30093 if (PyErr_Occurred()) SWIG_fail;
30094 }
30095 resultobj = SWIG_From_long(static_cast< long >(result));
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30103 PyObject *resultobj = 0;
30104 wxLongLong result;
30105
30106 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = wxGetLocalTimeMillis();
30110 wxPyEndAllowThreads(__tstate);
30111 if (PyErr_Occurred()) SWIG_fail;
30112 }
30113 {
30114 PyObject *hi, *lo, *shifter, *shifted;
30115 hi = PyLong_FromLong( (&result)->GetHi() );
30116 lo = PyLong_FromLong( (&result)->GetLo() );
30117 shifter = PyLong_FromLong(32);
30118 shifted = PyNumber_Lshift(hi, shifter);
30119 resultobj = PyNumber_Or(shifted, lo);
30120 Py_DECREF(hi);
30121 Py_DECREF(lo);
30122 Py_DECREF(shifter);
30123 Py_DECREF(shifted);
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30132 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30133 return 1;
30134 }
30135
30136
30137 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30138 PyObject *pyobj = 0;
30139
30140 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30141 return pyobj;
30142 }
30143
30144
30145 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj = 0;
30147 wxDataFormatId arg1 ;
30148 wxDataFormat *result = 0 ;
30149 int val1 ;
30150 int ecode1 = 0 ;
30151 PyObject * obj0 = 0 ;
30152 char * kwnames[] = {
30153 (char *) "type", NULL
30154 };
30155
30156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30157 ecode1 = SWIG_AsVal_int(obj0, &val1);
30158 if (!SWIG_IsOK(ecode1)) {
30159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30160 }
30161 arg1 = static_cast< wxDataFormatId >(val1);
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (wxDataFormat *)new wxDataFormat(arg1);
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = 0;
30177 wxString *arg1 = 0 ;
30178 wxDataFormat *result = 0 ;
30179 bool temp1 = false ;
30180 PyObject * obj0 = 0 ;
30181 char * kwnames[] = {
30182 (char *) "format", NULL
30183 };
30184
30185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30186 {
30187 arg1 = wxString_in_helper(obj0);
30188 if (arg1 == NULL) SWIG_fail;
30189 temp1 = true;
30190 }
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30198 {
30199 if (temp1)
30200 delete arg1;
30201 }
30202 return resultobj;
30203 fail:
30204 {
30205 if (temp1)
30206 delete arg1;
30207 }
30208 return NULL;
30209 }
30210
30211
30212 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30213 PyObject *resultobj = 0;
30214 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30215 void *argp1 = 0 ;
30216 int res1 = 0 ;
30217 PyObject *swig_obj[1] ;
30218
30219 if (!args) SWIG_fail;
30220 swig_obj[0] = args;
30221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30222 if (!SWIG_IsOK(res1)) {
30223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30224 }
30225 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 delete arg1;
30229
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 resultobj = SWIG_Py_Void();
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30241 PyObject *resultobj = 0;
30242 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30243 wxDataFormatId arg2 ;
30244 bool result;
30245 void *argp1 = 0 ;
30246 int res1 = 0 ;
30247 int val2 ;
30248 int ecode2 = 0 ;
30249
30250 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30252 if (!SWIG_IsOK(res1)) {
30253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30254 }
30255 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30256 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30257 if (!SWIG_IsOK(ecode2)) {
30258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30259 }
30260 arg2 = static_cast< wxDataFormatId >(val2);
30261 {
30262 PyThreadState* __tstate = wxPyBeginAllowThreads();
30263 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30264 wxPyEndAllowThreads(__tstate);
30265 if (PyErr_Occurred()) SWIG_fail;
30266 }
30267 {
30268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30269 }
30270 return resultobj;
30271 fail:
30272 return NULL;
30273 }
30274
30275
30276 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30277 PyObject *resultobj = 0;
30278 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30279 wxDataFormatId arg2 ;
30280 bool result;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 int val2 ;
30284 int ecode2 = 0 ;
30285
30286 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30288 if (!SWIG_IsOK(res1)) {
30289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30290 }
30291 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30292 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30293 if (!SWIG_IsOK(ecode2)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30295 }
30296 arg2 = static_cast< wxDataFormatId >(val2);
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 {
30304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30305 }
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30313 PyObject *resultobj = 0;
30314 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30315 wxDataFormat *arg2 = 0 ;
30316 bool result;
30317 void *argp1 = 0 ;
30318 int res1 = 0 ;
30319 void *argp2 = 0 ;
30320 int res2 = 0 ;
30321
30322 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30324 if (!SWIG_IsOK(res1)) {
30325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30326 }
30327 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30328 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30329 if (!SWIG_IsOK(res2)) {
30330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30331 }
30332 if (!argp2) {
30333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30334 }
30335 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 {
30343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30344 }
30345 return resultobj;
30346 fail:
30347 return NULL;
30348 }
30349
30350
30351 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30352 int argc;
30353 PyObject *argv[3];
30354
30355 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30356 --argc;
30357 if (argc == 2) {
30358 int _v = 0;
30359 {
30360 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30361 _v = SWIG_CheckState(res);
30362 }
30363 if (!_v) goto check_1;
30364 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30365 }
30366 check_1:
30367
30368 if (argc == 2) {
30369 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30370 }
30371
30372 fail:
30373 Py_INCREF(Py_NotImplemented);
30374 return Py_NotImplemented;
30375 }
30376
30377
30378 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30379 PyObject *resultobj = 0;
30380 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30381 wxDataFormat *arg2 = 0 ;
30382 bool result;
30383 void *argp1 = 0 ;
30384 int res1 = 0 ;
30385 void *argp2 = 0 ;
30386 int res2 = 0 ;
30387
30388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30392 }
30393 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30395 if (!SWIG_IsOK(res2)) {
30396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30397 }
30398 if (!argp2) {
30399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30400 }
30401 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30405 wxPyEndAllowThreads(__tstate);
30406 if (PyErr_Occurred()) SWIG_fail;
30407 }
30408 {
30409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30410 }
30411 return resultobj;
30412 fail:
30413 return NULL;
30414 }
30415
30416
30417 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30418 int argc;
30419 PyObject *argv[3];
30420
30421 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30422 --argc;
30423 if (argc == 2) {
30424 int _v = 0;
30425 {
30426 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30427 _v = SWIG_CheckState(res);
30428 }
30429 if (!_v) goto check_1;
30430 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30431 }
30432 check_1:
30433
30434 if (argc == 2) {
30435 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30436 }
30437
30438 fail:
30439 Py_INCREF(Py_NotImplemented);
30440 return Py_NotImplemented;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30445 PyObject *resultobj = 0;
30446 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30447 wxDataFormatId arg2 ;
30448 void *argp1 = 0 ;
30449 int res1 = 0 ;
30450 int val2 ;
30451 int ecode2 = 0 ;
30452 PyObject * obj0 = 0 ;
30453 PyObject * obj1 = 0 ;
30454 char * kwnames[] = {
30455 (char *) "self",(char *) "format", NULL
30456 };
30457
30458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30462 }
30463 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30464 ecode2 = SWIG_AsVal_int(obj1, &val2);
30465 if (!SWIG_IsOK(ecode2)) {
30466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30467 }
30468 arg2 = static_cast< wxDataFormatId >(val2);
30469 {
30470 PyThreadState* __tstate = wxPyBeginAllowThreads();
30471 (arg1)->SetType(arg2);
30472 wxPyEndAllowThreads(__tstate);
30473 if (PyErr_Occurred()) SWIG_fail;
30474 }
30475 resultobj = SWIG_Py_Void();
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 PyObject *resultobj = 0;
30484 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30485 wxDataFormatId result;
30486 void *argp1 = 0 ;
30487 int res1 = 0 ;
30488 PyObject *swig_obj[1] ;
30489
30490 if (!args) SWIG_fail;
30491 swig_obj[0] = args;
30492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30493 if (!SWIG_IsOK(res1)) {
30494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30495 }
30496 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_From_int(static_cast< int >(result));
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30513 wxString result;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30523 }
30524 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = ((wxDataFormat const *)arg1)->GetId();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 {
30532 #if wxUSE_UNICODE
30533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30534 #else
30535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30536 #endif
30537 }
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30547 wxString *arg2 = 0 ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 bool temp2 = false ;
30551 PyObject * obj0 = 0 ;
30552 PyObject * obj1 = 0 ;
30553 char * kwnames[] = {
30554 (char *) "self",(char *) "format", NULL
30555 };
30556
30557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30561 }
30562 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30563 {
30564 arg2 = wxString_in_helper(obj1);
30565 if (arg2 == NULL) SWIG_fail;
30566 temp2 = true;
30567 }
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->SetId((wxString const &)*arg2);
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 {
30576 if (temp2)
30577 delete arg2;
30578 }
30579 return resultobj;
30580 fail:
30581 {
30582 if (temp2)
30583 delete arg2;
30584 }
30585 return NULL;
30586 }
30587
30588
30589 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30590 PyObject *obj;
30591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30592 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30593 return SWIG_Py_Void();
30594 }
30595
30596 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30597 return SWIG_Python_InitShadowInstance(args);
30598 }
30599
30600 SWIGINTERN int FormatInvalid_set(PyObject *) {
30601 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30602 return 1;
30603 }
30604
30605
30606 SWIGINTERN PyObject *FormatInvalid_get(void) {
30607 PyObject *pyobj = 0;
30608
30609 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30610 return pyobj;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxDataObject *arg1 = (wxDataObject *) 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 PyObject *swig_obj[1] ;
30620
30621 if (!args) SWIG_fail;
30622 swig_obj[0] = args;
30623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30624 if (!SWIG_IsOK(res1)) {
30625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30626 }
30627 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 delete arg1;
30631
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 resultobj = SWIG_Py_Void();
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj = 0;
30644 wxDataObject *arg1 = (wxDataObject *) 0 ;
30645 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30646 SwigValueWrapper<wxDataFormat > result;
30647 void *argp1 = 0 ;
30648 int res1 = 0 ;
30649 int val2 ;
30650 int ecode2 = 0 ;
30651 PyObject * obj0 = 0 ;
30652 PyObject * obj1 = 0 ;
30653 char * kwnames[] = {
30654 (char *) "self",(char *) "dir", NULL
30655 };
30656
30657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30659 if (!SWIG_IsOK(res1)) {
30660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30661 }
30662 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30663 if (obj1) {
30664 ecode2 = SWIG_AsVal_int(obj1, &val2);
30665 if (!SWIG_IsOK(ecode2)) {
30666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30667 }
30668 arg2 = static_cast< wxDataObject::Direction >(val2);
30669 }
30670 {
30671 PyThreadState* __tstate = wxPyBeginAllowThreads();
30672 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30673 wxPyEndAllowThreads(__tstate);
30674 if (PyErr_Occurred()) SWIG_fail;
30675 }
30676 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30684 PyObject *resultobj = 0;
30685 wxDataObject *arg1 = (wxDataObject *) 0 ;
30686 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30687 size_t result;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 int val2 ;
30691 int ecode2 = 0 ;
30692 PyObject * obj0 = 0 ;
30693 PyObject * obj1 = 0 ;
30694 char * kwnames[] = {
30695 (char *) "self",(char *) "dir", NULL
30696 };
30697
30698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30700 if (!SWIG_IsOK(res1)) {
30701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30702 }
30703 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30704 if (obj1) {
30705 ecode2 = SWIG_AsVal_int(obj1, &val2);
30706 if (!SWIG_IsOK(ecode2)) {
30707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30708 }
30709 arg2 = static_cast< wxDataObject::Direction >(val2);
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj = 0;
30726 wxDataObject *arg1 = (wxDataObject *) 0 ;
30727 wxDataFormat *arg2 = 0 ;
30728 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30729 bool result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 void *argp2 = 0 ;
30733 int res2 = 0 ;
30734 int val3 ;
30735 int ecode3 = 0 ;
30736 PyObject * obj0 = 0 ;
30737 PyObject * obj1 = 0 ;
30738 PyObject * obj2 = 0 ;
30739 char * kwnames[] = {
30740 (char *) "self",(char *) "format",(char *) "dir", NULL
30741 };
30742
30743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30745 if (!SWIG_IsOK(res1)) {
30746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30747 }
30748 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30749 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30750 if (!SWIG_IsOK(res2)) {
30751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30752 }
30753 if (!argp2) {
30754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30755 }
30756 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30757 if (obj2) {
30758 ecode3 = SWIG_AsVal_int(obj2, &val3);
30759 if (!SWIG_IsOK(ecode3)) {
30760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30761 }
30762 arg3 = static_cast< wxDataObject::Direction >(val3);
30763 }
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 {
30771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30772 }
30773 return resultobj;
30774 fail:
30775 return NULL;
30776 }
30777
30778
30779 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30780 PyObject *resultobj = 0;
30781 wxDataObject *arg1 = (wxDataObject *) 0 ;
30782 wxDataFormat *arg2 = 0 ;
30783 size_t result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 void *argp2 = 0 ;
30787 int res2 = 0 ;
30788 PyObject * obj0 = 0 ;
30789 PyObject * obj1 = 0 ;
30790 char * kwnames[] = {
30791 (char *) "self",(char *) "format", NULL
30792 };
30793
30794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30796 if (!SWIG_IsOK(res1)) {
30797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30798 }
30799 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30801 if (!SWIG_IsOK(res2)) {
30802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30803 }
30804 if (!argp2) {
30805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30806 }
30807 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30808 {
30809 PyThreadState* __tstate = wxPyBeginAllowThreads();
30810 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj = 0;
30823 wxDataObject *arg1 = (wxDataObject *) 0 ;
30824 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30825 PyObject *result = 0 ;
30826 void *argp1 = 0 ;
30827 int res1 = 0 ;
30828 int val2 ;
30829 int ecode2 = 0 ;
30830 PyObject * obj0 = 0 ;
30831 PyObject * obj1 = 0 ;
30832 char * kwnames[] = {
30833 (char *) "self",(char *) "dir", NULL
30834 };
30835
30836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30840 }
30841 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30842 if (obj1) {
30843 ecode2 = SWIG_AsVal_int(obj1, &val2);
30844 if (!SWIG_IsOK(ecode2)) {
30845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30846 }
30847 arg2 = static_cast< wxDataObject::Direction >(val2);
30848 }
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 resultobj = result;
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30863 PyObject *resultobj = 0;
30864 wxDataObject *arg1 = (wxDataObject *) 0 ;
30865 wxDataFormat *arg2 = 0 ;
30866 PyObject *result = 0 ;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 void *argp2 = 0 ;
30870 int res2 = 0 ;
30871 PyObject * obj0 = 0 ;
30872 PyObject * obj1 = 0 ;
30873 char * kwnames[] = {
30874 (char *) "self",(char *) "format", NULL
30875 };
30876
30877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30879 if (!SWIG_IsOK(res1)) {
30880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30881 }
30882 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30884 if (!SWIG_IsOK(res2)) {
30885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30886 }
30887 if (!argp2) {
30888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30889 }
30890 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = result;
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj = 0;
30906 wxDataObject *arg1 = (wxDataObject *) 0 ;
30907 wxDataFormat *arg2 = 0 ;
30908 PyObject *arg3 = (PyObject *) 0 ;
30909 bool result;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 void *argp2 = 0 ;
30913 int res2 = 0 ;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 PyObject * obj2 = 0 ;
30917 char * kwnames[] = {
30918 (char *) "self",(char *) "format",(char *) "data", NULL
30919 };
30920
30921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30925 }
30926 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30928 if (!SWIG_IsOK(res2)) {
30929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30930 }
30931 if (!argp2) {
30932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30933 }
30934 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30935 arg3 = obj2;
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 {
30943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30944 }
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30952 PyObject *obj;
30953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30954 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30955 return SWIG_Py_Void();
30956 }
30957
30958 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj = 0;
30960 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
30961 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
30962 wxDataObjectSimple *result = 0 ;
30963 void *argp1 = 0 ;
30964 int res1 = 0 ;
30965 PyObject * obj0 = 0 ;
30966 char * kwnames[] = {
30967 (char *) "format", NULL
30968 };
30969
30970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
30971 if (obj0) {
30972 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
30973 if (!SWIG_IsOK(res1)) {
30974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30975 }
30976 if (!argp1) {
30977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30978 }
30979 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30980 }
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *resultobj = 0;
30996 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
30997 wxDataFormat *result = 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31007 }
31008 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 {
31012 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31013 result = (wxDataFormat *) &_result_ref;
31014 }
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31026 PyObject *resultobj = 0;
31027 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31028 wxDataFormat *arg2 = 0 ;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 void *argp2 = 0 ;
31032 int res2 = 0 ;
31033 PyObject * obj0 = 0 ;
31034 PyObject * obj1 = 0 ;
31035 char * kwnames[] = {
31036 (char *) "self",(char *) "format", NULL
31037 };
31038
31039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31043 }
31044 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31046 if (!SWIG_IsOK(res2)) {
31047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31048 }
31049 if (!argp2) {
31050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31051 }
31052 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31053 {
31054 PyThreadState* __tstate = wxPyBeginAllowThreads();
31055 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31056 wxPyEndAllowThreads(__tstate);
31057 if (PyErr_Occurred()) SWIG_fail;
31058 }
31059 resultobj = SWIG_Py_Void();
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31067 PyObject *resultobj = 0;
31068 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31069 size_t result;
31070 void *argp1 = 0 ;
31071 int res1 = 0 ;
31072 PyObject *swig_obj[1] ;
31073
31074 if (!args) SWIG_fail;
31075 swig_obj[0] = args;
31076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31077 if (!SWIG_IsOK(res1)) {
31078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31079 }
31080 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31095 PyObject *resultobj = 0;
31096 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31097 PyObject *result = 0 ;
31098 void *argp1 = 0 ;
31099 int res1 = 0 ;
31100 PyObject *swig_obj[1] ;
31101
31102 if (!args) SWIG_fail;
31103 swig_obj[0] = args;
31104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31105 if (!SWIG_IsOK(res1)) {
31106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31107 }
31108 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31112 wxPyEndAllowThreads(__tstate);
31113 if (PyErr_Occurred()) SWIG_fail;
31114 }
31115 resultobj = result;
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31123 PyObject *resultobj = 0;
31124 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31125 PyObject *arg2 = (PyObject *) 0 ;
31126 bool result;
31127 void *argp1 = 0 ;
31128 int res1 = 0 ;
31129 PyObject * obj0 = 0 ;
31130 PyObject * obj1 = 0 ;
31131 char * kwnames[] = {
31132 (char *) "self",(char *) "data", NULL
31133 };
31134
31135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31137 if (!SWIG_IsOK(res1)) {
31138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31139 }
31140 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31141 arg2 = obj1;
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 {
31149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31150 }
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31158 PyObject *obj;
31159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31160 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31161 return SWIG_Py_Void();
31162 }
31163
31164 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31165 return SWIG_Python_InitShadowInstance(args);
31166 }
31167
31168 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj = 0;
31170 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31171 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31172 wxPyDataObjectSimple *result = 0 ;
31173 void *argp1 = 0 ;
31174 int res1 = 0 ;
31175 PyObject * obj0 = 0 ;
31176 char * kwnames[] = {
31177 (char *) "format", NULL
31178 };
31179
31180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31181 if (obj0) {
31182 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31185 }
31186 if (!argp1) {
31187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31188 }
31189 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31190 }
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31194 wxPyEndAllowThreads(__tstate);
31195 if (PyErr_Occurred()) SWIG_fail;
31196 }
31197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31205 PyObject *resultobj = 0;
31206 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31207 PyObject *arg2 = (PyObject *) 0 ;
31208 PyObject *arg3 = (PyObject *) 0 ;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 PyObject * obj0 = 0 ;
31212 PyObject * obj1 = 0 ;
31213 PyObject * obj2 = 0 ;
31214 char * kwnames[] = {
31215 (char *) "self",(char *) "self",(char *) "_class", NULL
31216 };
31217
31218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31220 if (!SWIG_IsOK(res1)) {
31221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31222 }
31223 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31224 arg2 = obj1;
31225 arg3 = obj2;
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 (arg1)->_setCallbackInfo(arg2,arg3);
31229 wxPyEndAllowThreads(__tstate);
31230 if (PyErr_Occurred()) SWIG_fail;
31231 }
31232 resultobj = SWIG_Py_Void();
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31240 PyObject *obj;
31241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31242 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31243 return SWIG_Py_Void();
31244 }
31245
31246 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 return SWIG_Python_InitShadowInstance(args);
31248 }
31249
31250 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31251 PyObject *resultobj = 0;
31252 wxDataObjectComposite *result = 0 ;
31253
31254 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj = 0;
31270 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31271 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31272 bool arg3 = (bool) false ;
31273 void *argp1 = 0 ;
31274 int res1 = 0 ;
31275 int res2 = 0 ;
31276 bool val3 ;
31277 int ecode3 = 0 ;
31278 PyObject * obj0 = 0 ;
31279 PyObject * obj1 = 0 ;
31280 PyObject * obj2 = 0 ;
31281 char * kwnames[] = {
31282 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31283 };
31284
31285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31287 if (!SWIG_IsOK(res1)) {
31288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31289 }
31290 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31291 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31292 if (!SWIG_IsOK(res2)) {
31293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31294 }
31295 if (obj2) {
31296 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31297 if (!SWIG_IsOK(ecode3)) {
31298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31299 }
31300 arg3 = static_cast< bool >(val3);
31301 }
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 (arg1)->Add(arg2,arg3);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31316 PyObject *obj;
31317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31318 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31319 return SWIG_Py_Void();
31320 }
31321
31322 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 return SWIG_Python_InitShadowInstance(args);
31324 }
31325
31326 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31327 PyObject *resultobj = 0;
31328 wxString const &arg1_defvalue = wxPyEmptyString ;
31329 wxString *arg1 = (wxString *) &arg1_defvalue ;
31330 wxTextDataObject *result = 0 ;
31331 bool temp1 = false ;
31332 PyObject * obj0 = 0 ;
31333 char * kwnames[] = {
31334 (char *) "text", NULL
31335 };
31336
31337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31338 if (obj0) {
31339 {
31340 arg1 = wxString_in_helper(obj0);
31341 if (arg1 == NULL) SWIG_fail;
31342 temp1 = true;
31343 }
31344 }
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31352 {
31353 if (temp1)
31354 delete arg1;
31355 }
31356 return resultobj;
31357 fail:
31358 {
31359 if (temp1)
31360 delete arg1;
31361 }
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31367 PyObject *resultobj = 0;
31368 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31369 size_t result;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 PyObject *swig_obj[1] ;
31373
31374 if (!args) SWIG_fail;
31375 swig_obj[0] = args;
31376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31379 }
31380 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31381 {
31382 PyThreadState* __tstate = wxPyBeginAllowThreads();
31383 result = (size_t)(arg1)->GetTextLength();
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31395 PyObject *resultobj = 0;
31396 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31397 wxString result;
31398 void *argp1 = 0 ;
31399 int res1 = 0 ;
31400 PyObject *swig_obj[1] ;
31401
31402 if (!args) SWIG_fail;
31403 swig_obj[0] = args;
31404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31405 if (!SWIG_IsOK(res1)) {
31406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31407 }
31408 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31409 {
31410 PyThreadState* __tstate = wxPyBeginAllowThreads();
31411 result = (arg1)->GetText();
31412 wxPyEndAllowThreads(__tstate);
31413 if (PyErr_Occurred()) SWIG_fail;
31414 }
31415 {
31416 #if wxUSE_UNICODE
31417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31418 #else
31419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31420 #endif
31421 }
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj = 0;
31430 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31431 wxString *arg2 = 0 ;
31432 void *argp1 = 0 ;
31433 int res1 = 0 ;
31434 bool temp2 = false ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 char * kwnames[] = {
31438 (char *) "self",(char *) "text", NULL
31439 };
31440
31441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31443 if (!SWIG_IsOK(res1)) {
31444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31445 }
31446 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31447 {
31448 arg2 = wxString_in_helper(obj1);
31449 if (arg2 == NULL) SWIG_fail;
31450 temp2 = true;
31451 }
31452 {
31453 PyThreadState* __tstate = wxPyBeginAllowThreads();
31454 (arg1)->SetText((wxString const &)*arg2);
31455 wxPyEndAllowThreads(__tstate);
31456 if (PyErr_Occurred()) SWIG_fail;
31457 }
31458 resultobj = SWIG_Py_Void();
31459 {
31460 if (temp2)
31461 delete arg2;
31462 }
31463 return resultobj;
31464 fail:
31465 {
31466 if (temp2)
31467 delete arg2;
31468 }
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *obj;
31475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31476 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31477 return SWIG_Py_Void();
31478 }
31479
31480 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31481 return SWIG_Python_InitShadowInstance(args);
31482 }
31483
31484 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxString const &arg1_defvalue = wxPyEmptyString ;
31487 wxString *arg1 = (wxString *) &arg1_defvalue ;
31488 wxPyTextDataObject *result = 0 ;
31489 bool temp1 = false ;
31490 PyObject * obj0 = 0 ;
31491 char * kwnames[] = {
31492 (char *) "text", NULL
31493 };
31494
31495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31496 if (obj0) {
31497 {
31498 arg1 = wxString_in_helper(obj0);
31499 if (arg1 == NULL) SWIG_fail;
31500 temp1 = true;
31501 }
31502 }
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31510 {
31511 if (temp1)
31512 delete arg1;
31513 }
31514 return resultobj;
31515 fail:
31516 {
31517 if (temp1)
31518 delete arg1;
31519 }
31520 return NULL;
31521 }
31522
31523
31524 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31525 PyObject *resultobj = 0;
31526 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31527 PyObject *arg2 = (PyObject *) 0 ;
31528 PyObject *arg3 = (PyObject *) 0 ;
31529 void *argp1 = 0 ;
31530 int res1 = 0 ;
31531 PyObject * obj0 = 0 ;
31532 PyObject * obj1 = 0 ;
31533 PyObject * obj2 = 0 ;
31534 char * kwnames[] = {
31535 (char *) "self",(char *) "self",(char *) "_class", NULL
31536 };
31537
31538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31542 }
31543 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31544 arg2 = obj1;
31545 arg3 = obj2;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 (arg1)->_setCallbackInfo(arg2,arg3);
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *obj;
31561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31563 return SWIG_Py_Void();
31564 }
31565
31566 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31567 return SWIG_Python_InitShadowInstance(args);
31568 }
31569
31570 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj = 0;
31572 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31573 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31574 wxBitmapDataObject *result = 0 ;
31575 void *argp1 = 0 ;
31576 int res1 = 0 ;
31577 PyObject * obj0 = 0 ;
31578 char * kwnames[] = {
31579 (char *) "bitmap", NULL
31580 };
31581
31582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31583 if (obj0) {
31584 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31585 if (!SWIG_IsOK(res1)) {
31586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31587 }
31588 if (!argp1) {
31589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31590 }
31591 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31592 }
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31600 return resultobj;
31601 fail:
31602 return NULL;
31603 }
31604
31605
31606 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31607 PyObject *resultobj = 0;
31608 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31609 wxBitmap result;
31610 void *argp1 = 0 ;
31611 int res1 = 0 ;
31612 PyObject *swig_obj[1] ;
31613
31614 if (!args) SWIG_fail;
31615 swig_obj[0] = args;
31616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31619 }
31620 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31621 {
31622 PyThreadState* __tstate = wxPyBeginAllowThreads();
31623 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31624 wxPyEndAllowThreads(__tstate);
31625 if (PyErr_Occurred()) SWIG_fail;
31626 }
31627 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31628 return resultobj;
31629 fail:
31630 return NULL;
31631 }
31632
31633
31634 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31635 PyObject *resultobj = 0;
31636 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31637 wxBitmap *arg2 = 0 ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 void *argp2 = 0 ;
31641 int res2 = 0 ;
31642 PyObject * obj0 = 0 ;
31643 PyObject * obj1 = 0 ;
31644 char * kwnames[] = {
31645 (char *) "self",(char *) "bitmap", NULL
31646 };
31647
31648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31650 if (!SWIG_IsOK(res1)) {
31651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31652 }
31653 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31654 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31655 if (!SWIG_IsOK(res2)) {
31656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31657 }
31658 if (!argp2) {
31659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31660 }
31661 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_Py_Void();
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *obj;
31677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31678 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31679 return SWIG_Py_Void();
31680 }
31681
31682 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31683 return SWIG_Python_InitShadowInstance(args);
31684 }
31685
31686 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31687 PyObject *resultobj = 0;
31688 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31689 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31690 wxPyBitmapDataObject *result = 0 ;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 PyObject * obj0 = 0 ;
31694 char * kwnames[] = {
31695 (char *) "bitmap", NULL
31696 };
31697
31698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31699 if (obj0) {
31700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31701 if (!SWIG_IsOK(res1)) {
31702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31703 }
31704 if (!argp1) {
31705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31706 }
31707 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31708 }
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj = 0;
31724 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31725 PyObject *arg2 = (PyObject *) 0 ;
31726 PyObject *arg3 = (PyObject *) 0 ;
31727 void *argp1 = 0 ;
31728 int res1 = 0 ;
31729 PyObject * obj0 = 0 ;
31730 PyObject * obj1 = 0 ;
31731 PyObject * obj2 = 0 ;
31732 char * kwnames[] = {
31733 (char *) "self",(char *) "self",(char *) "_class", NULL
31734 };
31735
31736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31738 if (!SWIG_IsOK(res1)) {
31739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31740 }
31741 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31742 arg2 = obj1;
31743 arg3 = obj2;
31744 {
31745 PyThreadState* __tstate = wxPyBeginAllowThreads();
31746 (arg1)->_setCallbackInfo(arg2,arg3);
31747 wxPyEndAllowThreads(__tstate);
31748 if (PyErr_Occurred()) SWIG_fail;
31749 }
31750 resultobj = SWIG_Py_Void();
31751 return resultobj;
31752 fail:
31753 return NULL;
31754 }
31755
31756
31757 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31758 PyObject *obj;
31759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31760 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31761 return SWIG_Py_Void();
31762 }
31763
31764 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31765 return SWIG_Python_InitShadowInstance(args);
31766 }
31767
31768 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31769 PyObject *resultobj = 0;
31770 wxFileDataObject *result = 0 ;
31771
31772 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (wxFileDataObject *)new wxFileDataObject();
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31789 wxArrayString *result = 0 ;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31799 }
31800 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 {
31804 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31805 result = (wxArrayString *) &_result_ref;
31806 }
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 {
31811 resultobj = wxArrayString2PyList_helper(*result);
31812 }
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj = 0;
31821 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31822 wxString *arg2 = 0 ;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 bool temp2 = false ;
31826 PyObject * obj0 = 0 ;
31827 PyObject * obj1 = 0 ;
31828 char * kwnames[] = {
31829 (char *) "self",(char *) "filename", NULL
31830 };
31831
31832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31836 }
31837 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31838 {
31839 arg2 = wxString_in_helper(obj1);
31840 if (arg2 == NULL) SWIG_fail;
31841 temp2 = true;
31842 }
31843 {
31844 PyThreadState* __tstate = wxPyBeginAllowThreads();
31845 (arg1)->AddFile((wxString const &)*arg2);
31846 wxPyEndAllowThreads(__tstate);
31847 if (PyErr_Occurred()) SWIG_fail;
31848 }
31849 resultobj = SWIG_Py_Void();
31850 {
31851 if (temp2)
31852 delete arg2;
31853 }
31854 return resultobj;
31855 fail:
31856 {
31857 if (temp2)
31858 delete arg2;
31859 }
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31865 PyObject *obj;
31866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31867 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31868 return SWIG_Py_Void();
31869 }
31870
31871 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31872 return SWIG_Python_InitShadowInstance(args);
31873 }
31874
31875 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31876 PyObject *resultobj = 0;
31877 wxDataFormat *arg1 = 0 ;
31878 wxCustomDataObject *result = 0 ;
31879 void *argp1 = 0 ;
31880 int res1 = 0 ;
31881
31882 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31884 if (!SWIG_IsOK(res1)) {
31885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31886 }
31887 if (!argp1) {
31888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31889 }
31890 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31891 {
31892 PyThreadState* __tstate = wxPyBeginAllowThreads();
31893 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31894 wxPyEndAllowThreads(__tstate);
31895 if (PyErr_Occurred()) SWIG_fail;
31896 }
31897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31898 return resultobj;
31899 fail:
31900 return NULL;
31901 }
31902
31903
31904 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31905 PyObject *resultobj = 0;
31906 wxString *arg1 = 0 ;
31907 wxCustomDataObject *result = 0 ;
31908 bool temp1 = false ;
31909
31910 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31911 {
31912 arg1 = wxString_in_helper(swig_obj[0]);
31913 if (arg1 == NULL) SWIG_fail;
31914 temp1 = true;
31915 }
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31923 {
31924 if (temp1)
31925 delete arg1;
31926 }
31927 return resultobj;
31928 fail:
31929 {
31930 if (temp1)
31931 delete arg1;
31932 }
31933 return NULL;
31934 }
31935
31936
31937 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
31938 PyObject *resultobj = 0;
31939 wxCustomDataObject *result = 0 ;
31940
31941 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 result = (wxCustomDataObject *)new wxCustomDataObject();
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
31956 int argc;
31957 PyObject *argv[2];
31958
31959 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
31960 --argc;
31961 if (argc == 0) {
31962 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
31963 }
31964 if (argc == 1) {
31965 int _v = 0;
31966 {
31967 {
31968 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
31969 }
31970 }
31971 if (!_v) goto check_2;
31972 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
31973 }
31974 check_2:
31975
31976 if (argc == 1) {
31977 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
31978 }
31979
31980 fail:
31981 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31987 PyObject *resultobj = 0;
31988 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
31989 PyObject *arg2 = (PyObject *) 0 ;
31990 bool result;
31991 void *argp1 = 0 ;
31992 int res1 = 0 ;
31993 PyObject * obj0 = 0 ;
31994 PyObject * obj1 = 0 ;
31995 char * kwnames[] = {
31996 (char *) "self",(char *) "data", NULL
31997 };
31998
31999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32001 if (!SWIG_IsOK(res1)) {
32002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32003 }
32004 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32005 arg2 = obj1;
32006 {
32007 PyThreadState* __tstate = wxPyBeginAllowThreads();
32008 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32009 wxPyEndAllowThreads(__tstate);
32010 if (PyErr_Occurred()) SWIG_fail;
32011 }
32012 {
32013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32014 }
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32022 PyObject *resultobj = 0;
32023 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32024 size_t result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32034 }
32035 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (size_t)(arg1)->GetSize();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32050 PyObject *resultobj = 0;
32051 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32052 PyObject *result = 0 ;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 PyObject *swig_obj[1] ;
32056
32057 if (!args) SWIG_fail;
32058 swig_obj[0] = args;
32059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32060 if (!SWIG_IsOK(res1)) {
32061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32062 }
32063 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 resultobj = result;
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32078 PyObject *obj;
32079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32080 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32081 return SWIG_Py_Void();
32082 }
32083
32084 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 return SWIG_Python_InitShadowInstance(args);
32086 }
32087
32088 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxURLDataObject *result = 0 ;
32091
32092 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (wxURLDataObject *)new wxURLDataObject();
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32100 return resultobj;
32101 fail:
32102 return NULL;
32103 }
32104
32105
32106 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32107 PyObject *resultobj = 0;
32108 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32109 wxString result;
32110 void *argp1 = 0 ;
32111 int res1 = 0 ;
32112 PyObject *swig_obj[1] ;
32113
32114 if (!args) SWIG_fail;
32115 swig_obj[0] = args;
32116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32117 if (!SWIG_IsOK(res1)) {
32118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32119 }
32120 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (arg1)->GetURL();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 {
32128 #if wxUSE_UNICODE
32129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32130 #else
32131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32132 #endif
32133 }
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj = 0;
32142 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32143 wxString *arg2 = 0 ;
32144 void *argp1 = 0 ;
32145 int res1 = 0 ;
32146 bool temp2 = false ;
32147 PyObject * obj0 = 0 ;
32148 PyObject * obj1 = 0 ;
32149 char * kwnames[] = {
32150 (char *) "self",(char *) "url", NULL
32151 };
32152
32153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32157 }
32158 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32159 {
32160 arg2 = wxString_in_helper(obj1);
32161 if (arg2 == NULL) SWIG_fail;
32162 temp2 = true;
32163 }
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 (arg1)->SetURL((wxString const &)*arg2);
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_Py_Void();
32171 {
32172 if (temp2)
32173 delete arg2;
32174 }
32175 return resultobj;
32176 fail:
32177 {
32178 if (temp2)
32179 delete arg2;
32180 }
32181 return NULL;
32182 }
32183
32184
32185 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32186 PyObject *obj;
32187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32188 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32189 return SWIG_Py_Void();
32190 }
32191
32192 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 return SWIG_Python_InitShadowInstance(args);
32194 }
32195
32196 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32197 PyObject *resultobj = 0;
32198 wxMetafileDataObject *result = 0 ;
32199
32200 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32208 return resultobj;
32209 fail:
32210 return NULL;
32211 }
32212
32213
32214 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32215 PyObject *obj;
32216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32217 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32218 return SWIG_Py_Void();
32219 }
32220
32221 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32222 return SWIG_Python_InitShadowInstance(args);
32223 }
32224
32225 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32226 PyObject *resultobj = 0;
32227 wxDragResult arg1 ;
32228 bool result;
32229 int val1 ;
32230 int ecode1 = 0 ;
32231 PyObject * obj0 = 0 ;
32232 char * kwnames[] = {
32233 (char *) "res", NULL
32234 };
32235
32236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32237 ecode1 = SWIG_AsVal_int(obj0, &val1);
32238 if (!SWIG_IsOK(ecode1)) {
32239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32240 }
32241 arg1 = static_cast< wxDragResult >(val1);
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (bool)wxIsDragResultOk(arg1);
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 {
32249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32250 }
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32258 PyObject *resultobj = 0;
32259 wxWindow *arg1 = (wxWindow *) 0 ;
32260 wxIcon const &arg2_defvalue = wxNullIcon ;
32261 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32262 wxIcon const &arg3_defvalue = wxNullIcon ;
32263 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32264 wxIcon const &arg4_defvalue = wxNullIcon ;
32265 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32266 wxPyDropSource *result = 0 ;
32267 void *argp1 = 0 ;
32268 int res1 = 0 ;
32269 void *argp2 = 0 ;
32270 int res2 = 0 ;
32271 void *argp3 = 0 ;
32272 int res3 = 0 ;
32273 void *argp4 = 0 ;
32274 int res4 = 0 ;
32275 PyObject * obj0 = 0 ;
32276 PyObject * obj1 = 0 ;
32277 PyObject * obj2 = 0 ;
32278 PyObject * obj3 = 0 ;
32279 char * kwnames[] = {
32280 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32281 };
32282
32283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32285 if (!SWIG_IsOK(res1)) {
32286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32287 }
32288 arg1 = reinterpret_cast< wxWindow * >(argp1);
32289 if (obj1) {
32290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32291 if (!SWIG_IsOK(res2)) {
32292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32293 }
32294 if (!argp2) {
32295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32296 }
32297 arg2 = reinterpret_cast< wxIcon * >(argp2);
32298 }
32299 if (obj2) {
32300 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32301 if (!SWIG_IsOK(res3)) {
32302 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32303 }
32304 if (!argp3) {
32305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32306 }
32307 arg3 = reinterpret_cast< wxIcon * >(argp3);
32308 }
32309 if (obj3) {
32310 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32311 if (!SWIG_IsOK(res4)) {
32312 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32313 }
32314 if (!argp4) {
32315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32316 }
32317 arg4 = reinterpret_cast< wxIcon * >(argp4);
32318 }
32319 {
32320 PyThreadState* __tstate = wxPyBeginAllowThreads();
32321 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32326 return resultobj;
32327 fail:
32328 return NULL;
32329 }
32330
32331
32332 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32333 PyObject *resultobj = 0;
32334 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32335 PyObject *arg2 = (PyObject *) 0 ;
32336 PyObject *arg3 = (PyObject *) 0 ;
32337 int arg4 ;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 int val4 ;
32341 int ecode4 = 0 ;
32342 PyObject * obj0 = 0 ;
32343 PyObject * obj1 = 0 ;
32344 PyObject * obj2 = 0 ;
32345 PyObject * obj3 = 0 ;
32346 char * kwnames[] = {
32347 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32348 };
32349
32350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32352 if (!SWIG_IsOK(res1)) {
32353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32354 }
32355 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32356 arg2 = obj1;
32357 arg3 = obj2;
32358 ecode4 = SWIG_AsVal_int(obj3, &val4);
32359 if (!SWIG_IsOK(ecode4)) {
32360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32361 }
32362 arg4 = static_cast< int >(val4);
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 resultobj = SWIG_Py_Void();
32370 return resultobj;
32371 fail:
32372 return NULL;
32373 }
32374
32375
32376 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32377 PyObject *resultobj = 0;
32378 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32379 void *argp1 = 0 ;
32380 int res1 = 0 ;
32381 PyObject *swig_obj[1] ;
32382
32383 if (!args) SWIG_fail;
32384 swig_obj[0] = args;
32385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32386 if (!SWIG_IsOK(res1)) {
32387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32388 }
32389 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 delete arg1;
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 resultobj = SWIG_Py_Void();
32398 return resultobj;
32399 fail:
32400 return NULL;
32401 }
32402
32403
32404 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32405 PyObject *resultobj = 0;
32406 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32407 wxDataObject *arg2 = 0 ;
32408 void *argp1 = 0 ;
32409 int res1 = 0 ;
32410 void *argp2 = 0 ;
32411 int res2 = 0 ;
32412 PyObject * obj0 = 0 ;
32413 PyObject * obj1 = 0 ;
32414 char * kwnames[] = {
32415 (char *) "self",(char *) "data", NULL
32416 };
32417
32418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32422 }
32423 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32425 if (!SWIG_IsOK(res2)) {
32426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32427 }
32428 if (!argp2) {
32429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32430 }
32431 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32432 {
32433 PyThreadState* __tstate = wxPyBeginAllowThreads();
32434 (arg1)->SetData(*arg2);
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 resultobj = SWIG_Py_Void();
32439 return resultobj;
32440 fail:
32441 return NULL;
32442 }
32443
32444
32445 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32446 PyObject *resultobj = 0;
32447 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32448 wxDataObject *result = 0 ;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 PyObject *swig_obj[1] ;
32452
32453 if (!args) SWIG_fail;
32454 swig_obj[0] = args;
32455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32456 if (!SWIG_IsOK(res1)) {
32457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32458 }
32459 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32460 {
32461 PyThreadState* __tstate = wxPyBeginAllowThreads();
32462 result = (wxDataObject *)(arg1)->GetDataObject();
32463 wxPyEndAllowThreads(__tstate);
32464 if (PyErr_Occurred()) SWIG_fail;
32465 }
32466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32467 return resultobj;
32468 fail:
32469 return NULL;
32470 }
32471
32472
32473 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32474 PyObject *resultobj = 0;
32475 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32476 wxDragResult arg2 ;
32477 wxCursor *arg3 = 0 ;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 int val2 ;
32481 int ecode2 = 0 ;
32482 void *argp3 = 0 ;
32483 int res3 = 0 ;
32484 PyObject * obj0 = 0 ;
32485 PyObject * obj1 = 0 ;
32486 PyObject * obj2 = 0 ;
32487 char * kwnames[] = {
32488 (char *) "self",(char *) "res",(char *) "cursor", NULL
32489 };
32490
32491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32493 if (!SWIG_IsOK(res1)) {
32494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32495 }
32496 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32497 ecode2 = SWIG_AsVal_int(obj1, &val2);
32498 if (!SWIG_IsOK(ecode2)) {
32499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32500 }
32501 arg2 = static_cast< wxDragResult >(val2);
32502 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32503 if (!SWIG_IsOK(res3)) {
32504 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32505 }
32506 if (!argp3) {
32507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32508 }
32509 arg3 = reinterpret_cast< wxCursor * >(argp3);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_Py_Void();
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32524 PyObject *resultobj = 0;
32525 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32526 int arg2 = (int) wxDrag_CopyOnly ;
32527 wxDragResult result;
32528 void *argp1 = 0 ;
32529 int res1 = 0 ;
32530 int val2 ;
32531 int ecode2 = 0 ;
32532 PyObject * obj0 = 0 ;
32533 PyObject * obj1 = 0 ;
32534 char * kwnames[] = {
32535 (char *) "self",(char *) "flags", NULL
32536 };
32537
32538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32540 if (!SWIG_IsOK(res1)) {
32541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32542 }
32543 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32544 if (obj1) {
32545 ecode2 = SWIG_AsVal_int(obj1, &val2);
32546 if (!SWIG_IsOK(ecode2)) {
32547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32548 }
32549 arg2 = static_cast< int >(val2);
32550 }
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 resultobj = SWIG_From_int(static_cast< int >(result));
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = 0;
32566 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32567 wxDragResult arg2 ;
32568 bool result;
32569 void *argp1 = 0 ;
32570 int res1 = 0 ;
32571 int val2 ;
32572 int ecode2 = 0 ;
32573 PyObject * obj0 = 0 ;
32574 PyObject * obj1 = 0 ;
32575 char * kwnames[] = {
32576 (char *) "self",(char *) "effect", NULL
32577 };
32578
32579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32583 }
32584 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32585 ecode2 = SWIG_AsVal_int(obj1, &val2);
32586 if (!SWIG_IsOK(ecode2)) {
32587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32588 }
32589 arg2 = static_cast< wxDragResult >(val2);
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (bool)(arg1)->GiveFeedback(arg2);
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *obj;
32607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32608 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32609 return SWIG_Py_Void();
32610 }
32611
32612 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32613 return SWIG_Python_InitShadowInstance(args);
32614 }
32615
32616 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32617 PyObject *resultobj = 0;
32618 wxDataObject *arg1 = (wxDataObject *) NULL ;
32619 wxPyDropTarget *result = 0 ;
32620 int res1 = 0 ;
32621 PyObject * obj0 = 0 ;
32622 char * kwnames[] = {
32623 (char *) "dataObject", NULL
32624 };
32625
32626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32627 if (obj0) {
32628 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32629 if (!SWIG_IsOK(res1)) {
32630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32631 }
32632 }
32633 {
32634 PyThreadState* __tstate = wxPyBeginAllowThreads();
32635 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32636 wxPyEndAllowThreads(__tstate);
32637 if (PyErr_Occurred()) SWIG_fail;
32638 }
32639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32647 PyObject *resultobj = 0;
32648 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32649 PyObject *arg2 = (PyObject *) 0 ;
32650 PyObject *arg3 = (PyObject *) 0 ;
32651 void *argp1 = 0 ;
32652 int res1 = 0 ;
32653 PyObject * obj0 = 0 ;
32654 PyObject * obj1 = 0 ;
32655 PyObject * obj2 = 0 ;
32656 char * kwnames[] = {
32657 (char *) "self",(char *) "self",(char *) "_class", NULL
32658 };
32659
32660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32664 }
32665 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32666 arg2 = obj1;
32667 arg3 = obj2;
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 (arg1)->_setCallbackInfo(arg2,arg3);
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 resultobj = SWIG_Py_Void();
32675 return resultobj;
32676 fail:
32677 return NULL;
32678 }
32679
32680
32681 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32682 PyObject *resultobj = 0;
32683 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 PyObject *swig_obj[1] ;
32687
32688 if (!args) SWIG_fail;
32689 swig_obj[0] = args;
32690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32691 if (!SWIG_IsOK(res1)) {
32692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32693 }
32694 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 delete arg1;
32698
32699 wxPyEndAllowThreads(__tstate);
32700 if (PyErr_Occurred()) SWIG_fail;
32701 }
32702 resultobj = SWIG_Py_Void();
32703 return resultobj;
32704 fail:
32705 return NULL;
32706 }
32707
32708
32709 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32710 PyObject *resultobj = 0;
32711 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32712 wxDataObject *result = 0 ;
32713 void *argp1 = 0 ;
32714 int res1 = 0 ;
32715 PyObject *swig_obj[1] ;
32716
32717 if (!args) SWIG_fail;
32718 swig_obj[0] = args;
32719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32720 if (!SWIG_IsOK(res1)) {
32721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32722 }
32723 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32724 {
32725 PyThreadState* __tstate = wxPyBeginAllowThreads();
32726 result = (wxDataObject *)(arg1)->GetDataObject();
32727 wxPyEndAllowThreads(__tstate);
32728 if (PyErr_Occurred()) SWIG_fail;
32729 }
32730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32731 return resultobj;
32732 fail:
32733 return NULL;
32734 }
32735
32736
32737 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32738 PyObject *resultobj = 0;
32739 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32740 wxDataObject *arg2 = (wxDataObject *) 0 ;
32741 void *argp1 = 0 ;
32742 int res1 = 0 ;
32743 int res2 = 0 ;
32744 PyObject * obj0 = 0 ;
32745 PyObject * obj1 = 0 ;
32746 char * kwnames[] = {
32747 (char *) "self",(char *) "dataObject", NULL
32748 };
32749
32750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32754 }
32755 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32756 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32757 if (!SWIG_IsOK(res2)) {
32758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32759 }
32760 {
32761 PyThreadState* __tstate = wxPyBeginAllowThreads();
32762 (arg1)->SetDataObject(arg2);
32763 wxPyEndAllowThreads(__tstate);
32764 if (PyErr_Occurred()) SWIG_fail;
32765 }
32766 resultobj = SWIG_Py_Void();
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj = 0;
32775 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32776 int arg2 ;
32777 int arg3 ;
32778 wxDragResult arg4 ;
32779 wxDragResult result;
32780 void *argp1 = 0 ;
32781 int res1 = 0 ;
32782 int val2 ;
32783 int ecode2 = 0 ;
32784 int val3 ;
32785 int ecode3 = 0 ;
32786 int val4 ;
32787 int ecode4 = 0 ;
32788 PyObject * obj0 = 0 ;
32789 PyObject * obj1 = 0 ;
32790 PyObject * obj2 = 0 ;
32791 PyObject * obj3 = 0 ;
32792 char * kwnames[] = {
32793 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32794 };
32795
32796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32800 }
32801 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32802 ecode2 = SWIG_AsVal_int(obj1, &val2);
32803 if (!SWIG_IsOK(ecode2)) {
32804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32805 }
32806 arg2 = static_cast< int >(val2);
32807 ecode3 = SWIG_AsVal_int(obj2, &val3);
32808 if (!SWIG_IsOK(ecode3)) {
32809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32810 }
32811 arg3 = static_cast< int >(val3);
32812 ecode4 = SWIG_AsVal_int(obj3, &val4);
32813 if (!SWIG_IsOK(ecode4)) {
32814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32815 }
32816 arg4 = static_cast< wxDragResult >(val4);
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 resultobj = SWIG_From_int(static_cast< int >(result));
32824 return resultobj;
32825 fail:
32826 return NULL;
32827 }
32828
32829
32830 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32831 PyObject *resultobj = 0;
32832 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32833 int arg2 ;
32834 int arg3 ;
32835 wxDragResult arg4 ;
32836 wxDragResult result;
32837 void *argp1 = 0 ;
32838 int res1 = 0 ;
32839 int val2 ;
32840 int ecode2 = 0 ;
32841 int val3 ;
32842 int ecode3 = 0 ;
32843 int val4 ;
32844 int ecode4 = 0 ;
32845 PyObject * obj0 = 0 ;
32846 PyObject * obj1 = 0 ;
32847 PyObject * obj2 = 0 ;
32848 PyObject * obj3 = 0 ;
32849 char * kwnames[] = {
32850 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32851 };
32852
32853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32855 if (!SWIG_IsOK(res1)) {
32856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32857 }
32858 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32859 ecode2 = SWIG_AsVal_int(obj1, &val2);
32860 if (!SWIG_IsOK(ecode2)) {
32861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32862 }
32863 arg2 = static_cast< int >(val2);
32864 ecode3 = SWIG_AsVal_int(obj2, &val3);
32865 if (!SWIG_IsOK(ecode3)) {
32866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32867 }
32868 arg3 = static_cast< int >(val3);
32869 ecode4 = SWIG_AsVal_int(obj3, &val4);
32870 if (!SWIG_IsOK(ecode4)) {
32871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32872 }
32873 arg4 = static_cast< wxDragResult >(val4);
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 resultobj = SWIG_From_int(static_cast< int >(result));
32881 return resultobj;
32882 fail:
32883 return NULL;
32884 }
32885
32886
32887 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32888 PyObject *resultobj = 0;
32889 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32890 void *argp1 = 0 ;
32891 int res1 = 0 ;
32892 PyObject *swig_obj[1] ;
32893
32894 if (!args) SWIG_fail;
32895 swig_obj[0] = args;
32896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32897 if (!SWIG_IsOK(res1)) {
32898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32899 }
32900 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32901 {
32902 PyThreadState* __tstate = wxPyBeginAllowThreads();
32903 (arg1)->OnLeave();
32904 wxPyEndAllowThreads(__tstate);
32905 if (PyErr_Occurred()) SWIG_fail;
32906 }
32907 resultobj = SWIG_Py_Void();
32908 return resultobj;
32909 fail:
32910 return NULL;
32911 }
32912
32913
32914 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32915 PyObject *resultobj = 0;
32916 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32917 int arg2 ;
32918 int arg3 ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 int val2 ;
32923 int ecode2 = 0 ;
32924 int val3 ;
32925 int ecode3 = 0 ;
32926 PyObject * obj0 = 0 ;
32927 PyObject * obj1 = 0 ;
32928 PyObject * obj2 = 0 ;
32929 char * kwnames[] = {
32930 (char *) "self",(char *) "x",(char *) "y", NULL
32931 };
32932
32933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32935 if (!SWIG_IsOK(res1)) {
32936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32937 }
32938 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32939 ecode2 = SWIG_AsVal_int(obj1, &val2);
32940 if (!SWIG_IsOK(ecode2)) {
32941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
32942 }
32943 arg2 = static_cast< int >(val2);
32944 ecode3 = SWIG_AsVal_int(obj2, &val3);
32945 if (!SWIG_IsOK(ecode3)) {
32946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
32947 }
32948 arg3 = static_cast< int >(val3);
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (bool)(arg1)->OnDrop(arg2,arg3);
32952 wxPyEndAllowThreads(__tstate);
32953 if (PyErr_Occurred()) SWIG_fail;
32954 }
32955 {
32956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32957 }
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32967 bool result;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32977 }
32978 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (bool)(arg1)->GetData();
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 {
32986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32987 }
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32995 PyObject *resultobj = 0;
32996 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32997 wxDragResult arg2 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 int val2 ;
33001 int ecode2 = 0 ;
33002 PyObject * obj0 = 0 ;
33003 PyObject * obj1 = 0 ;
33004 char * kwnames[] = {
33005 (char *) "self",(char *) "action", NULL
33006 };
33007
33008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33012 }
33013 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33014 ecode2 = SWIG_AsVal_int(obj1, &val2);
33015 if (!SWIG_IsOK(ecode2)) {
33016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33017 }
33018 arg2 = static_cast< wxDragResult >(val2);
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 (arg1)->SetDefaultAction(arg2);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_Py_Void();
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33033 PyObject *resultobj = 0;
33034 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33035 wxDragResult result;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 PyObject *swig_obj[1] ;
33039
33040 if (!args) SWIG_fail;
33041 swig_obj[0] = args;
33042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33045 }
33046 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33047 {
33048 PyThreadState* __tstate = wxPyBeginAllowThreads();
33049 result = (wxDragResult)(arg1)->GetDefaultAction();
33050 wxPyEndAllowThreads(__tstate);
33051 if (PyErr_Occurred()) SWIG_fail;
33052 }
33053 resultobj = SWIG_From_int(static_cast< int >(result));
33054 return resultobj;
33055 fail:
33056 return NULL;
33057 }
33058
33059
33060 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33061 PyObject *obj;
33062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33064 return SWIG_Py_Void();
33065 }
33066
33067 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33068 return SWIG_Python_InitShadowInstance(args);
33069 }
33070
33071 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33072 PyObject *resultobj = 0;
33073 wxPyTextDropTarget *result = 0 ;
33074
33075 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33076 {
33077 PyThreadState* __tstate = wxPyBeginAllowThreads();
33078 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33079 wxPyEndAllowThreads(__tstate);
33080 if (PyErr_Occurred()) SWIG_fail;
33081 }
33082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33083 return resultobj;
33084 fail:
33085 return NULL;
33086 }
33087
33088
33089 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33090 PyObject *resultobj = 0;
33091 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33092 PyObject *arg2 = (PyObject *) 0 ;
33093 PyObject *arg3 = (PyObject *) 0 ;
33094 void *argp1 = 0 ;
33095 int res1 = 0 ;
33096 PyObject * obj0 = 0 ;
33097 PyObject * obj1 = 0 ;
33098 PyObject * obj2 = 0 ;
33099 char * kwnames[] = {
33100 (char *) "self",(char *) "self",(char *) "_class", NULL
33101 };
33102
33103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33105 if (!SWIG_IsOK(res1)) {
33106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33107 }
33108 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33109 arg2 = obj1;
33110 arg3 = obj2;
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 (arg1)->_setCallbackInfo(arg2,arg3);
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 resultobj = SWIG_Py_Void();
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33125 PyObject *resultobj = 0;
33126 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33127 int arg2 ;
33128 int arg3 ;
33129 wxString *arg4 = 0 ;
33130 bool result;
33131 void *argp1 = 0 ;
33132 int res1 = 0 ;
33133 int val2 ;
33134 int ecode2 = 0 ;
33135 int val3 ;
33136 int ecode3 = 0 ;
33137 bool temp4 = false ;
33138 PyObject * obj0 = 0 ;
33139 PyObject * obj1 = 0 ;
33140 PyObject * obj2 = 0 ;
33141 PyObject * obj3 = 0 ;
33142 char * kwnames[] = {
33143 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33144 };
33145
33146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33148 if (!SWIG_IsOK(res1)) {
33149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33150 }
33151 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33152 ecode2 = SWIG_AsVal_int(obj1, &val2);
33153 if (!SWIG_IsOK(ecode2)) {
33154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33155 }
33156 arg2 = static_cast< int >(val2);
33157 ecode3 = SWIG_AsVal_int(obj2, &val3);
33158 if (!SWIG_IsOK(ecode3)) {
33159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33160 }
33161 arg3 = static_cast< int >(val3);
33162 {
33163 arg4 = wxString_in_helper(obj3);
33164 if (arg4 == NULL) SWIG_fail;
33165 temp4 = true;
33166 }
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 {
33174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33175 }
33176 {
33177 if (temp4)
33178 delete arg4;
33179 }
33180 return resultobj;
33181 fail:
33182 {
33183 if (temp4)
33184 delete arg4;
33185 }
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33191 PyObject *resultobj = 0;
33192 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33193 int arg2 ;
33194 int arg3 ;
33195 wxDragResult arg4 ;
33196 wxDragResult result;
33197 void *argp1 = 0 ;
33198 int res1 = 0 ;
33199 int val2 ;
33200 int ecode2 = 0 ;
33201 int val3 ;
33202 int ecode3 = 0 ;
33203 int val4 ;
33204 int ecode4 = 0 ;
33205 PyObject * obj0 = 0 ;
33206 PyObject * obj1 = 0 ;
33207 PyObject * obj2 = 0 ;
33208 PyObject * obj3 = 0 ;
33209 char * kwnames[] = {
33210 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33211 };
33212
33213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33215 if (!SWIG_IsOK(res1)) {
33216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33217 }
33218 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33219 ecode2 = SWIG_AsVal_int(obj1, &val2);
33220 if (!SWIG_IsOK(ecode2)) {
33221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33222 }
33223 arg2 = static_cast< int >(val2);
33224 ecode3 = SWIG_AsVal_int(obj2, &val3);
33225 if (!SWIG_IsOK(ecode3)) {
33226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33227 }
33228 arg3 = static_cast< int >(val3);
33229 ecode4 = SWIG_AsVal_int(obj3, &val4);
33230 if (!SWIG_IsOK(ecode4)) {
33231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33232 }
33233 arg4 = static_cast< wxDragResult >(val4);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33237 wxPyEndAllowThreads(__tstate);
33238 if (PyErr_Occurred()) SWIG_fail;
33239 }
33240 resultobj = SWIG_From_int(static_cast< int >(result));
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = 0;
33249 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33250 int arg2 ;
33251 int arg3 ;
33252 wxDragResult arg4 ;
33253 wxDragResult result;
33254 void *argp1 = 0 ;
33255 int res1 = 0 ;
33256 int val2 ;
33257 int ecode2 = 0 ;
33258 int val3 ;
33259 int ecode3 = 0 ;
33260 int val4 ;
33261 int ecode4 = 0 ;
33262 PyObject * obj0 = 0 ;
33263 PyObject * obj1 = 0 ;
33264 PyObject * obj2 = 0 ;
33265 PyObject * obj3 = 0 ;
33266 char * kwnames[] = {
33267 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33268 };
33269
33270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33274 }
33275 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33276 ecode2 = SWIG_AsVal_int(obj1, &val2);
33277 if (!SWIG_IsOK(ecode2)) {
33278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33279 }
33280 arg2 = static_cast< int >(val2);
33281 ecode3 = SWIG_AsVal_int(obj2, &val3);
33282 if (!SWIG_IsOK(ecode3)) {
33283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33284 }
33285 arg3 = static_cast< int >(val3);
33286 ecode4 = SWIG_AsVal_int(obj3, &val4);
33287 if (!SWIG_IsOK(ecode4)) {
33288 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33289 }
33290 arg4 = static_cast< wxDragResult >(val4);
33291 {
33292 PyThreadState* __tstate = wxPyBeginAllowThreads();
33293 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33294 wxPyEndAllowThreads(__tstate);
33295 if (PyErr_Occurred()) SWIG_fail;
33296 }
33297 resultobj = SWIG_From_int(static_cast< int >(result));
33298 return resultobj;
33299 fail:
33300 return NULL;
33301 }
33302
33303
33304 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33305 PyObject *resultobj = 0;
33306 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33307 void *argp1 = 0 ;
33308 int res1 = 0 ;
33309 PyObject *swig_obj[1] ;
33310
33311 if (!args) SWIG_fail;
33312 swig_obj[0] = args;
33313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33314 if (!SWIG_IsOK(res1)) {
33315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33316 }
33317 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33318 {
33319 PyThreadState* __tstate = wxPyBeginAllowThreads();
33320 (arg1)->OnLeave();
33321 wxPyEndAllowThreads(__tstate);
33322 if (PyErr_Occurred()) SWIG_fail;
33323 }
33324 resultobj = SWIG_Py_Void();
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33332 PyObject *resultobj = 0;
33333 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33334 int arg2 ;
33335 int arg3 ;
33336 bool result;
33337 void *argp1 = 0 ;
33338 int res1 = 0 ;
33339 int val2 ;
33340 int ecode2 = 0 ;
33341 int val3 ;
33342 int ecode3 = 0 ;
33343 PyObject * obj0 = 0 ;
33344 PyObject * obj1 = 0 ;
33345 PyObject * obj2 = 0 ;
33346 char * kwnames[] = {
33347 (char *) "self",(char *) "x",(char *) "y", NULL
33348 };
33349
33350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33352 if (!SWIG_IsOK(res1)) {
33353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33354 }
33355 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33356 ecode2 = SWIG_AsVal_int(obj1, &val2);
33357 if (!SWIG_IsOK(ecode2)) {
33358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33359 }
33360 arg2 = static_cast< int >(val2);
33361 ecode3 = SWIG_AsVal_int(obj2, &val3);
33362 if (!SWIG_IsOK(ecode3)) {
33363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33364 }
33365 arg3 = static_cast< int >(val3);
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (bool)(arg1)->OnDrop(arg2,arg3);
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj = 0;
33383 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33384 int arg2 ;
33385 int arg3 ;
33386 wxDragResult arg4 ;
33387 wxDragResult result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 int val2 ;
33391 int ecode2 = 0 ;
33392 int val3 ;
33393 int ecode3 = 0 ;
33394 int val4 ;
33395 int ecode4 = 0 ;
33396 PyObject * obj0 = 0 ;
33397 PyObject * obj1 = 0 ;
33398 PyObject * obj2 = 0 ;
33399 PyObject * obj3 = 0 ;
33400 char * kwnames[] = {
33401 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33402 };
33403
33404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33406 if (!SWIG_IsOK(res1)) {
33407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33408 }
33409 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33410 ecode2 = SWIG_AsVal_int(obj1, &val2);
33411 if (!SWIG_IsOK(ecode2)) {
33412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33413 }
33414 arg2 = static_cast< int >(val2);
33415 ecode3 = SWIG_AsVal_int(obj2, &val3);
33416 if (!SWIG_IsOK(ecode3)) {
33417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33418 }
33419 arg3 = static_cast< int >(val3);
33420 ecode4 = SWIG_AsVal_int(obj3, &val4);
33421 if (!SWIG_IsOK(ecode4)) {
33422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33423 }
33424 arg4 = static_cast< wxDragResult >(val4);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_From_int(static_cast< int >(result));
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *obj;
33440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33441 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33442 return SWIG_Py_Void();
33443 }
33444
33445 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33446 return SWIG_Python_InitShadowInstance(args);
33447 }
33448
33449 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33450 PyObject *resultobj = 0;
33451 wxPyFileDropTarget *result = 0 ;
33452
33453 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33454 {
33455 PyThreadState* __tstate = wxPyBeginAllowThreads();
33456 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33457 wxPyEndAllowThreads(__tstate);
33458 if (PyErr_Occurred()) SWIG_fail;
33459 }
33460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33461 return resultobj;
33462 fail:
33463 return NULL;
33464 }
33465
33466
33467 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33468 PyObject *resultobj = 0;
33469 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33470 PyObject *arg2 = (PyObject *) 0 ;
33471 PyObject *arg3 = (PyObject *) 0 ;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 PyObject * obj0 = 0 ;
33475 PyObject * obj1 = 0 ;
33476 PyObject * obj2 = 0 ;
33477 char * kwnames[] = {
33478 (char *) "self",(char *) "self",(char *) "_class", NULL
33479 };
33480
33481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33483 if (!SWIG_IsOK(res1)) {
33484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33485 }
33486 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33487 arg2 = obj1;
33488 arg3 = obj2;
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 (arg1)->_setCallbackInfo(arg2,arg3);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_Py_Void();
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj = 0;
33504 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33505 int arg2 ;
33506 int arg3 ;
33507 wxArrayString *arg4 = 0 ;
33508 bool result;
33509 void *argp1 = 0 ;
33510 int res1 = 0 ;
33511 int val2 ;
33512 int ecode2 = 0 ;
33513 int val3 ;
33514 int ecode3 = 0 ;
33515 bool temp4 = false ;
33516 PyObject * obj0 = 0 ;
33517 PyObject * obj1 = 0 ;
33518 PyObject * obj2 = 0 ;
33519 PyObject * obj3 = 0 ;
33520 char * kwnames[] = {
33521 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33522 };
33523
33524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33526 if (!SWIG_IsOK(res1)) {
33527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33528 }
33529 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33530 ecode2 = SWIG_AsVal_int(obj1, &val2);
33531 if (!SWIG_IsOK(ecode2)) {
33532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33533 }
33534 arg2 = static_cast< int >(val2);
33535 ecode3 = SWIG_AsVal_int(obj2, &val3);
33536 if (!SWIG_IsOK(ecode3)) {
33537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33538 }
33539 arg3 = static_cast< int >(val3);
33540 {
33541 if (! PySequence_Check(obj3)) {
33542 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33543 SWIG_fail;
33544 }
33545 arg4 = new wxArrayString;
33546 temp4 = true;
33547 int i, len=PySequence_Length(obj3);
33548 for (i=0; i<len; i++) {
33549 PyObject* item = PySequence_GetItem(obj3, i);
33550 wxString* s = wxString_in_helper(item);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 arg4->Add(*s);
33553 delete s;
33554 Py_DECREF(item);
33555 }
33556 }
33557 {
33558 PyThreadState* __tstate = wxPyBeginAllowThreads();
33559 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33560 wxPyEndAllowThreads(__tstate);
33561 if (PyErr_Occurred()) SWIG_fail;
33562 }
33563 {
33564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33565 }
33566 {
33567 if (temp4) delete arg4;
33568 }
33569 return resultobj;
33570 fail:
33571 {
33572 if (temp4) delete arg4;
33573 }
33574 return NULL;
33575 }
33576
33577
33578 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33579 PyObject *resultobj = 0;
33580 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33581 int arg2 ;
33582 int arg3 ;
33583 wxDragResult arg4 ;
33584 wxDragResult result;
33585 void *argp1 = 0 ;
33586 int res1 = 0 ;
33587 int val2 ;
33588 int ecode2 = 0 ;
33589 int val3 ;
33590 int ecode3 = 0 ;
33591 int val4 ;
33592 int ecode4 = 0 ;
33593 PyObject * obj0 = 0 ;
33594 PyObject * obj1 = 0 ;
33595 PyObject * obj2 = 0 ;
33596 PyObject * obj3 = 0 ;
33597 char * kwnames[] = {
33598 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33599 };
33600
33601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33603 if (!SWIG_IsOK(res1)) {
33604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33605 }
33606 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33607 ecode2 = SWIG_AsVal_int(obj1, &val2);
33608 if (!SWIG_IsOK(ecode2)) {
33609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33610 }
33611 arg2 = static_cast< int >(val2);
33612 ecode3 = SWIG_AsVal_int(obj2, &val3);
33613 if (!SWIG_IsOK(ecode3)) {
33614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33615 }
33616 arg3 = static_cast< int >(val3);
33617 ecode4 = SWIG_AsVal_int(obj3, &val4);
33618 if (!SWIG_IsOK(ecode4)) {
33619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33620 }
33621 arg4 = static_cast< wxDragResult >(val4);
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 resultobj = SWIG_From_int(static_cast< int >(result));
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33636 PyObject *resultobj = 0;
33637 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33638 int arg2 ;
33639 int arg3 ;
33640 wxDragResult arg4 ;
33641 wxDragResult result;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 int val2 ;
33645 int ecode2 = 0 ;
33646 int val3 ;
33647 int ecode3 = 0 ;
33648 int val4 ;
33649 int ecode4 = 0 ;
33650 PyObject * obj0 = 0 ;
33651 PyObject * obj1 = 0 ;
33652 PyObject * obj2 = 0 ;
33653 PyObject * obj3 = 0 ;
33654 char * kwnames[] = {
33655 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33656 };
33657
33658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33660 if (!SWIG_IsOK(res1)) {
33661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33662 }
33663 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33664 ecode2 = SWIG_AsVal_int(obj1, &val2);
33665 if (!SWIG_IsOK(ecode2)) {
33666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33667 }
33668 arg2 = static_cast< int >(val2);
33669 ecode3 = SWIG_AsVal_int(obj2, &val3);
33670 if (!SWIG_IsOK(ecode3)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33672 }
33673 arg3 = static_cast< int >(val3);
33674 ecode4 = SWIG_AsVal_int(obj3, &val4);
33675 if (!SWIG_IsOK(ecode4)) {
33676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33677 }
33678 arg4 = static_cast< wxDragResult >(val4);
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33682 wxPyEndAllowThreads(__tstate);
33683 if (PyErr_Occurred()) SWIG_fail;
33684 }
33685 resultobj = SWIG_From_int(static_cast< int >(result));
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33693 PyObject *resultobj = 0;
33694 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33695 void *argp1 = 0 ;
33696 int res1 = 0 ;
33697 PyObject *swig_obj[1] ;
33698
33699 if (!args) SWIG_fail;
33700 swig_obj[0] = args;
33701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33704 }
33705 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 (arg1)->OnLeave();
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 resultobj = SWIG_Py_Void();
33713 return resultobj;
33714 fail:
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33720 PyObject *resultobj = 0;
33721 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33722 int arg2 ;
33723 int arg3 ;
33724 bool result;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 int val2 ;
33728 int ecode2 = 0 ;
33729 int val3 ;
33730 int ecode3 = 0 ;
33731 PyObject * obj0 = 0 ;
33732 PyObject * obj1 = 0 ;
33733 PyObject * obj2 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "x",(char *) "y", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33742 }
33743 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33744 ecode2 = SWIG_AsVal_int(obj1, &val2);
33745 if (!SWIG_IsOK(ecode2)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33747 }
33748 arg2 = static_cast< int >(val2);
33749 ecode3 = SWIG_AsVal_int(obj2, &val3);
33750 if (!SWIG_IsOK(ecode3)) {
33751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33752 }
33753 arg3 = static_cast< int >(val3);
33754 {
33755 PyThreadState* __tstate = wxPyBeginAllowThreads();
33756 result = (bool)(arg1)->OnDrop(arg2,arg3);
33757 wxPyEndAllowThreads(__tstate);
33758 if (PyErr_Occurred()) SWIG_fail;
33759 }
33760 {
33761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33762 }
33763 return resultobj;
33764 fail:
33765 return NULL;
33766 }
33767
33768
33769 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33770 PyObject *resultobj = 0;
33771 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33772 int arg2 ;
33773 int arg3 ;
33774 wxDragResult arg4 ;
33775 wxDragResult result;
33776 void *argp1 = 0 ;
33777 int res1 = 0 ;
33778 int val2 ;
33779 int ecode2 = 0 ;
33780 int val3 ;
33781 int ecode3 = 0 ;
33782 int val4 ;
33783 int ecode4 = 0 ;
33784 PyObject * obj0 = 0 ;
33785 PyObject * obj1 = 0 ;
33786 PyObject * obj2 = 0 ;
33787 PyObject * obj3 = 0 ;
33788 char * kwnames[] = {
33789 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33790 };
33791
33792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33794 if (!SWIG_IsOK(res1)) {
33795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33796 }
33797 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33798 ecode2 = SWIG_AsVal_int(obj1, &val2);
33799 if (!SWIG_IsOK(ecode2)) {
33800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33801 }
33802 arg2 = static_cast< int >(val2);
33803 ecode3 = SWIG_AsVal_int(obj2, &val3);
33804 if (!SWIG_IsOK(ecode3)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33806 }
33807 arg3 = static_cast< int >(val3);
33808 ecode4 = SWIG_AsVal_int(obj3, &val4);
33809 if (!SWIG_IsOK(ecode4)) {
33810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33811 }
33812 arg4 = static_cast< wxDragResult >(val4);
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 resultobj = SWIG_From_int(static_cast< int >(result));
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33827 PyObject *obj;
33828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33829 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33830 return SWIG_Py_Void();
33831 }
33832
33833 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33834 return SWIG_Python_InitShadowInstance(args);
33835 }
33836
33837 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33838 PyObject *resultobj = 0;
33839 wxClipboard *result = 0 ;
33840
33841 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (wxClipboard *)new wxClipboard();
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33856 PyObject *resultobj = 0;
33857 wxClipboard *arg1 = (wxClipboard *) 0 ;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33867 }
33868 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 delete arg1;
33872
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 resultobj = SWIG_Py_Void();
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33884 PyObject *resultobj = 0;
33885 wxClipboard *arg1 = (wxClipboard *) 0 ;
33886 bool result;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33896 }
33897 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)(arg1)->Open();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxClipboard *arg1 = (wxClipboard *) 0 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 PyObject *swig_obj[1] ;
33919
33920 if (!args) SWIG_fail;
33921 swig_obj[0] = args;
33922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33923 if (!SWIG_IsOK(res1)) {
33924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
33925 }
33926 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->Close();
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33941 PyObject *resultobj = 0;
33942 wxClipboard *arg1 = (wxClipboard *) 0 ;
33943 bool result;
33944 void *argp1 = 0 ;
33945 int res1 = 0 ;
33946 PyObject *swig_obj[1] ;
33947
33948 if (!args) SWIG_fail;
33949 swig_obj[0] = args;
33950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33951 if (!SWIG_IsOK(res1)) {
33952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
33953 }
33954 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33955 {
33956 PyThreadState* __tstate = wxPyBeginAllowThreads();
33957 result = (bool)((wxClipboard const *)arg1)->IsOpened();
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 {
33962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33963 }
33964 return resultobj;
33965 fail:
33966 return NULL;
33967 }
33968
33969
33970 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33971 PyObject *resultobj = 0;
33972 wxClipboard *arg1 = (wxClipboard *) 0 ;
33973 wxDataObject *arg2 = (wxDataObject *) 0 ;
33974 bool result;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 int res2 = 0 ;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char * kwnames[] = {
33981 (char *) "self",(char *) "data", NULL
33982 };
33983
33984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
33985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33986 if (!SWIG_IsOK(res1)) {
33987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
33988 }
33989 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33990 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33991 if (!SWIG_IsOK(res2)) {
33992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
33993 }
33994 {
33995 PyThreadState* __tstate = wxPyBeginAllowThreads();
33996 result = (bool)(arg1)->AddData(arg2);
33997 wxPyEndAllowThreads(__tstate);
33998 if (PyErr_Occurred()) SWIG_fail;
33999 }
34000 {
34001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34002 }
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxClipboard *arg1 = (wxClipboard *) 0 ;
34012 wxDataObject *arg2 = (wxDataObject *) 0 ;
34013 bool result;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 int res2 = 0 ;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "data", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34027 }
34028 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34029 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34030 if (!SWIG_IsOK(res2)) {
34031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34032 }
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (bool)(arg1)->SetData(arg2);
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 {
34040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34041 }
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxClipboard *arg1 = (wxClipboard *) 0 ;
34051 wxDataFormat *arg2 = 0 ;
34052 bool result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 void *argp2 = 0 ;
34056 int res2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "format", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34067 }
34068 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34070 if (!SWIG_IsOK(res2)) {
34071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34072 }
34073 if (!argp2) {
34074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34075 }
34076 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34077 {
34078 PyThreadState* __tstate = wxPyBeginAllowThreads();
34079 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34080 wxPyEndAllowThreads(__tstate);
34081 if (PyErr_Occurred()) SWIG_fail;
34082 }
34083 {
34084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34085 }
34086 return resultobj;
34087 fail:
34088 return NULL;
34089 }
34090
34091
34092 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34093 PyObject *resultobj = 0;
34094 wxClipboard *arg1 = (wxClipboard *) 0 ;
34095 wxDataObject *arg2 = 0 ;
34096 bool result;
34097 void *argp1 = 0 ;
34098 int res1 = 0 ;
34099 void *argp2 = 0 ;
34100 int res2 = 0 ;
34101 PyObject * obj0 = 0 ;
34102 PyObject * obj1 = 0 ;
34103 char * kwnames[] = {
34104 (char *) "self",(char *) "data", NULL
34105 };
34106
34107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34109 if (!SWIG_IsOK(res1)) {
34110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34111 }
34112 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34114 if (!SWIG_IsOK(res2)) {
34115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34116 }
34117 if (!argp2) {
34118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34119 }
34120 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34121 {
34122 PyThreadState* __tstate = wxPyBeginAllowThreads();
34123 result = (bool)(arg1)->GetData(*arg2);
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 {
34128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34129 }
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34137 PyObject *resultobj = 0;
34138 wxClipboard *arg1 = (wxClipboard *) 0 ;
34139 void *argp1 = 0 ;
34140 int res1 = 0 ;
34141 PyObject *swig_obj[1] ;
34142
34143 if (!args) SWIG_fail;
34144 swig_obj[0] = args;
34145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34146 if (!SWIG_IsOK(res1)) {
34147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34148 }
34149 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 (arg1)->Clear();
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_Py_Void();
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34164 PyObject *resultobj = 0;
34165 wxClipboard *arg1 = (wxClipboard *) 0 ;
34166 bool result;
34167 void *argp1 = 0 ;
34168 int res1 = 0 ;
34169 PyObject *swig_obj[1] ;
34170
34171 if (!args) SWIG_fail;
34172 swig_obj[0] = args;
34173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34176 }
34177 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (bool)(arg1)->Flush();
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 {
34185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34186 }
34187 return resultobj;
34188 fail:
34189 return NULL;
34190 }
34191
34192
34193 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34194 PyObject *resultobj = 0;
34195 wxClipboard *arg1 = (wxClipboard *) 0 ;
34196 bool arg2 = (bool) true ;
34197 void *argp1 = 0 ;
34198 int res1 = 0 ;
34199 bool val2 ;
34200 int ecode2 = 0 ;
34201 PyObject * obj0 = 0 ;
34202 PyObject * obj1 = 0 ;
34203 char * kwnames[] = {
34204 (char *) "self",(char *) "primary", NULL
34205 };
34206
34207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34211 }
34212 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34213 if (obj1) {
34214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34215 if (!SWIG_IsOK(ecode2)) {
34216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34217 }
34218 arg2 = static_cast< bool >(val2);
34219 }
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 (arg1)->UsePrimarySelection(arg2);
34223 wxPyEndAllowThreads(__tstate);
34224 if (PyErr_Occurred()) SWIG_fail;
34225 }
34226 resultobj = SWIG_Py_Void();
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34234 PyObject *resultobj = 0;
34235 wxClipboard *result = 0 ;
34236
34237 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = (wxClipboard *)wxClipboard::Get();
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *obj;
34253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34254 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34255 return SWIG_Py_Void();
34256 }
34257
34258 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34259 return SWIG_Python_InitShadowInstance(args);
34260 }
34261
34262 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34263 PyObject *resultobj = 0;
34264 wxClipboard *arg1 = (wxClipboard *) NULL ;
34265 wxClipboardLocker *result = 0 ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 PyObject * obj0 = 0 ;
34269 char * kwnames[] = {
34270 (char *) "clipboard", NULL
34271 };
34272
34273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34274 if (obj0) {
34275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34278 }
34279 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34280 }
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34295 PyObject *resultobj = 0;
34296 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 PyObject *swig_obj[1] ;
34300
34301 if (!args) SWIG_fail;
34302 swig_obj[0] = args;
34303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34304 if (!SWIG_IsOK(res1)) {
34305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34306 }
34307 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 delete arg1;
34311
34312 wxPyEndAllowThreads(__tstate);
34313 if (PyErr_Occurred()) SWIG_fail;
34314 }
34315 resultobj = SWIG_Py_Void();
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34323 PyObject *resultobj = 0;
34324 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34325 bool result;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 PyObject *swig_obj[1] ;
34329
34330 if (!args) SWIG_fail;
34331 swig_obj[0] = args;
34332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34333 if (!SWIG_IsOK(res1)) {
34334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34335 }
34336 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34337 {
34338 PyThreadState* __tstate = wxPyBeginAllowThreads();
34339 result = (bool)wxClipboardLocker___nonzero__(arg1);
34340 wxPyEndAllowThreads(__tstate);
34341 if (PyErr_Occurred()) SWIG_fail;
34342 }
34343 {
34344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34345 }
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34353 PyObject *obj;
34354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34355 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34356 return SWIG_Py_Void();
34357 }
34358
34359 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34360 return SWIG_Python_InitShadowInstance(args);
34361 }
34362
34363 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj = 0;
34365 int arg1 = (int) 0 ;
34366 int arg2 = (int) 0 ;
34367 int arg3 = (int) 0 ;
34368 int arg4 = (int) 0 ;
34369 wxVideoMode *result = 0 ;
34370 int val1 ;
34371 int ecode1 = 0 ;
34372 int val2 ;
34373 int ecode2 = 0 ;
34374 int val3 ;
34375 int ecode3 = 0 ;
34376 int val4 ;
34377 int ecode4 = 0 ;
34378 PyObject * obj0 = 0 ;
34379 PyObject * obj1 = 0 ;
34380 PyObject * obj2 = 0 ;
34381 PyObject * obj3 = 0 ;
34382 char * kwnames[] = {
34383 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34384 };
34385
34386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34387 if (obj0) {
34388 ecode1 = SWIG_AsVal_int(obj0, &val1);
34389 if (!SWIG_IsOK(ecode1)) {
34390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34391 }
34392 arg1 = static_cast< int >(val1);
34393 }
34394 if (obj1) {
34395 ecode2 = SWIG_AsVal_int(obj1, &val2);
34396 if (!SWIG_IsOK(ecode2)) {
34397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34398 }
34399 arg2 = static_cast< int >(val2);
34400 }
34401 if (obj2) {
34402 ecode3 = SWIG_AsVal_int(obj2, &val3);
34403 if (!SWIG_IsOK(ecode3)) {
34404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34405 }
34406 arg3 = static_cast< int >(val3);
34407 }
34408 if (obj3) {
34409 ecode4 = SWIG_AsVal_int(obj3, &val4);
34410 if (!SWIG_IsOK(ecode4)) {
34411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34412 }
34413 arg4 = static_cast< int >(val4);
34414 }
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34422 return resultobj;
34423 fail:
34424 return NULL;
34425 }
34426
34427
34428 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34429 PyObject *resultobj = 0;
34430 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34431 void *argp1 = 0 ;
34432 int res1 = 0 ;
34433 PyObject *swig_obj[1] ;
34434
34435 if (!args) SWIG_fail;
34436 swig_obj[0] = args;
34437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34438 if (!SWIG_IsOK(res1)) {
34439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34440 }
34441 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 delete arg1;
34445
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34457 PyObject *resultobj = 0;
34458 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34459 wxVideoMode *arg2 = 0 ;
34460 bool result;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 void *argp2 = 0 ;
34464 int res2 = 0 ;
34465 PyObject * obj0 = 0 ;
34466 PyObject * obj1 = 0 ;
34467 char * kwnames[] = {
34468 (char *) "self",(char *) "other", NULL
34469 };
34470
34471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34475 }
34476 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34478 if (!SWIG_IsOK(res2)) {
34479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34480 }
34481 if (!argp2) {
34482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34483 }
34484 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34485 {
34486 PyThreadState* __tstate = wxPyBeginAllowThreads();
34487 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34488 wxPyEndAllowThreads(__tstate);
34489 if (PyErr_Occurred()) SWIG_fail;
34490 }
34491 {
34492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34493 }
34494 return resultobj;
34495 fail:
34496 return NULL;
34497 }
34498
34499
34500 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34501 PyObject *resultobj = 0;
34502 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34503 int result;
34504 void *argp1 = 0 ;
34505 int res1 = 0 ;
34506 PyObject *swig_obj[1] ;
34507
34508 if (!args) SWIG_fail;
34509 swig_obj[0] = args;
34510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34511 if (!SWIG_IsOK(res1)) {
34512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34513 }
34514 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34515 {
34516 PyThreadState* __tstate = wxPyBeginAllowThreads();
34517 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34518 wxPyEndAllowThreads(__tstate);
34519 if (PyErr_Occurred()) SWIG_fail;
34520 }
34521 resultobj = SWIG_From_int(static_cast< int >(result));
34522 return resultobj;
34523 fail:
34524 return NULL;
34525 }
34526
34527
34528 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 PyObject *resultobj = 0;
34530 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34531 int result;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 PyObject *swig_obj[1] ;
34535
34536 if (!args) SWIG_fail;
34537 swig_obj[0] = args;
34538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34541 }
34542 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 resultobj = SWIG_From_int(static_cast< int >(result));
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34557 PyObject *resultobj = 0;
34558 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34559 int result;
34560 void *argp1 = 0 ;
34561 int res1 = 0 ;
34562 PyObject *swig_obj[1] ;
34563
34564 if (!args) SWIG_fail;
34565 swig_obj[0] = args;
34566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34567 if (!SWIG_IsOK(res1)) {
34568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34569 }
34570 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34571 {
34572 PyThreadState* __tstate = wxPyBeginAllowThreads();
34573 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 resultobj = SWIG_From_int(static_cast< int >(result));
34578 return resultobj;
34579 fail:
34580 return NULL;
34581 }
34582
34583
34584 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34585 PyObject *resultobj = 0;
34586 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34587 bool result;
34588 void *argp1 = 0 ;
34589 int res1 = 0 ;
34590 PyObject *swig_obj[1] ;
34591
34592 if (!args) SWIG_fail;
34593 swig_obj[0] = args;
34594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34595 if (!SWIG_IsOK(res1)) {
34596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34597 }
34598 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34599 {
34600 PyThreadState* __tstate = wxPyBeginAllowThreads();
34601 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34602 wxPyEndAllowThreads(__tstate);
34603 if (PyErr_Occurred()) SWIG_fail;
34604 }
34605 {
34606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34607 }
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj = 0;
34616 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34617 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34618 bool result;
34619 void *argp1 = 0 ;
34620 int res1 = 0 ;
34621 void *argp2 = 0 ;
34622 int res2 = 0 ;
34623 PyObject * obj0 = 0 ;
34624 PyObject * obj1 = 0 ;
34625 char * kwnames[] = {
34626 (char *) "self",(char *) "other", NULL
34627 };
34628
34629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34631 if (!SWIG_IsOK(res1)) {
34632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34633 }
34634 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34636 if (!SWIG_IsOK(res2)) {
34637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34638 }
34639 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 {
34647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34648 }
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj = 0;
34657 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34658 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 void *argp2 = 0 ;
34663 int res2 = 0 ;
34664 PyObject * obj0 = 0 ;
34665 PyObject * obj1 = 0 ;
34666 char * kwnames[] = {
34667 (char *) "self",(char *) "other", NULL
34668 };
34669
34670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34672 if (!SWIG_IsOK(res1)) {
34673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34674 }
34675 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34677 if (!SWIG_IsOK(res2)) {
34678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34679 }
34680 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 {
34688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34689 }
34690 return resultobj;
34691 fail:
34692 return NULL;
34693 }
34694
34695
34696 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34697 PyObject *resultobj = 0;
34698 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34699 int arg2 ;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 int val2 ;
34703 int ecode2 = 0 ;
34704 PyObject *swig_obj[2] ;
34705
34706 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34708 if (!SWIG_IsOK(res1)) {
34709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34710 }
34711 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34712 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34713 if (!SWIG_IsOK(ecode2)) {
34714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34715 }
34716 arg2 = static_cast< int >(val2);
34717 if (arg1) (arg1)->w = arg2;
34718
34719 resultobj = SWIG_Py_Void();
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_VideoMode_w_get(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_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34739 }
34740 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34741 result = (int) ((arg1)->w);
34742 resultobj = SWIG_From_int(static_cast< int >(result));
34743 return resultobj;
34744 fail:
34745 return NULL;
34746 }
34747
34748
34749 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34750 PyObject *resultobj = 0;
34751 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34752 int arg2 ;
34753 void *argp1 = 0 ;
34754 int res1 = 0 ;
34755 int val2 ;
34756 int ecode2 = 0 ;
34757 PyObject *swig_obj[2] ;
34758
34759 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34761 if (!SWIG_IsOK(res1)) {
34762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34763 }
34764 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34765 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34766 if (!SWIG_IsOK(ecode2)) {
34767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34768 }
34769 arg2 = static_cast< int >(val2);
34770 if (arg1) (arg1)->h = arg2;
34771
34772 resultobj = SWIG_Py_Void();
34773 return resultobj;
34774 fail:
34775 return NULL;
34776 }
34777
34778
34779 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34780 PyObject *resultobj = 0;
34781 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34782 int result;
34783 void *argp1 = 0 ;
34784 int res1 = 0 ;
34785 PyObject *swig_obj[1] ;
34786
34787 if (!args) SWIG_fail;
34788 swig_obj[0] = args;
34789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34790 if (!SWIG_IsOK(res1)) {
34791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34792 }
34793 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34794 result = (int) ((arg1)->h);
34795 resultobj = SWIG_From_int(static_cast< int >(result));
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34803 PyObject *resultobj = 0;
34804 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34805 int arg2 ;
34806 void *argp1 = 0 ;
34807 int res1 = 0 ;
34808 int val2 ;
34809 int ecode2 = 0 ;
34810 PyObject *swig_obj[2] ;
34811
34812 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34814 if (!SWIG_IsOK(res1)) {
34815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34816 }
34817 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34818 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34819 if (!SWIG_IsOK(ecode2)) {
34820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34821 }
34822 arg2 = static_cast< int >(val2);
34823 if (arg1) (arg1)->bpp = arg2;
34824
34825 resultobj = SWIG_Py_Void();
34826 return resultobj;
34827 fail:
34828 return NULL;
34829 }
34830
34831
34832 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34833 PyObject *resultobj = 0;
34834 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34835 int result;
34836 void *argp1 = 0 ;
34837 int res1 = 0 ;
34838 PyObject *swig_obj[1] ;
34839
34840 if (!args) SWIG_fail;
34841 swig_obj[0] = args;
34842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34843 if (!SWIG_IsOK(res1)) {
34844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34845 }
34846 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34847 result = (int) ((arg1)->bpp);
34848 resultobj = SWIG_From_int(static_cast< int >(result));
34849 return resultobj;
34850 fail:
34851 return NULL;
34852 }
34853
34854
34855 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34856 PyObject *resultobj = 0;
34857 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34858 int arg2 ;
34859 void *argp1 = 0 ;
34860 int res1 = 0 ;
34861 int val2 ;
34862 int ecode2 = 0 ;
34863 PyObject *swig_obj[2] ;
34864
34865 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34867 if (!SWIG_IsOK(res1)) {
34868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34869 }
34870 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34871 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34872 if (!SWIG_IsOK(ecode2)) {
34873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34874 }
34875 arg2 = static_cast< int >(val2);
34876 if (arg1) (arg1)->refresh = arg2;
34877
34878 resultobj = SWIG_Py_Void();
34879 return resultobj;
34880 fail:
34881 return NULL;
34882 }
34883
34884
34885 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34886 PyObject *resultobj = 0;
34887 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34888 int result;
34889 void *argp1 = 0 ;
34890 int res1 = 0 ;
34891 PyObject *swig_obj[1] ;
34892
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34898 }
34899 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34900 result = (int) ((arg1)->refresh);
34901 resultobj = SWIG_From_int(static_cast< int >(result));
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34909 PyObject *obj;
34910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34911 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34912 return SWIG_Py_Void();
34913 }
34914
34915 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34916 return SWIG_Python_InitShadowInstance(args);
34917 }
34918
34919 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34920 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
34921 return 1;
34922 }
34923
34924
34925 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
34926 PyObject *pyobj = 0;
34927
34928 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
34929 return pyobj;
34930 }
34931
34932
34933 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34934 PyObject *resultobj = 0;
34935 size_t arg1 = (size_t) 0 ;
34936 wxDisplay *result = 0 ;
34937 size_t val1 ;
34938 int ecode1 = 0 ;
34939 PyObject * obj0 = 0 ;
34940 char * kwnames[] = {
34941 (char *) "index", NULL
34942 };
34943
34944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
34945 if (obj0) {
34946 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
34947 if (!SWIG_IsOK(ecode1)) {
34948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
34949 }
34950 arg1 = static_cast< size_t >(val1);
34951 }
34952 {
34953 PyThreadState* __tstate = wxPyBeginAllowThreads();
34954 result = (wxDisplay *)new wxDisplay(arg1);
34955 wxPyEndAllowThreads(__tstate);
34956 if (PyErr_Occurred()) SWIG_fail;
34957 }
34958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
34959 return resultobj;
34960 fail:
34961 return NULL;
34962 }
34963
34964
34965 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34966 PyObject *resultobj = 0;
34967 wxDisplay *arg1 = (wxDisplay *) 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject *swig_obj[1] ;
34971
34972 if (!args) SWIG_fail;
34973 swig_obj[0] = args;
34974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
34977 }
34978 arg1 = reinterpret_cast< wxDisplay * >(argp1);
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 delete arg1;
34982
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 resultobj = SWIG_Py_Void();
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34994 PyObject *resultobj = 0;
34995 size_t result;
34996
34997 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 result = (size_t)wxDisplay::GetCount();
35001 wxPyEndAllowThreads(__tstate);
35002 if (PyErr_Occurred()) SWIG_fail;
35003 }
35004 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35005 return resultobj;
35006 fail:
35007 return NULL;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35012 PyObject *resultobj = 0;
35013 wxPoint *arg1 = 0 ;
35014 int result;
35015 wxPoint temp1 ;
35016 PyObject * obj0 = 0 ;
35017 char * kwnames[] = {
35018 (char *) "pt", NULL
35019 };
35020
35021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35022 {
35023 arg1 = &temp1;
35024 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35025 }
35026 {
35027 PyThreadState* __tstate = wxPyBeginAllowThreads();
35028 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35029 wxPyEndAllowThreads(__tstate);
35030 if (PyErr_Occurred()) SWIG_fail;
35031 }
35032 resultobj = SWIG_From_int(static_cast< int >(result));
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35040 PyObject *resultobj = 0;
35041 wxWindow *arg1 = (wxWindow *) 0 ;
35042 int result;
35043 void *argp1 = 0 ;
35044 int res1 = 0 ;
35045 PyObject * obj0 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "window", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 PyThreadState* __tstate = wxPyBeginAllowThreads();
35058 result = (int)wxDisplay::GetFromWindow(arg1);
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 resultobj = SWIG_From_int(static_cast< int >(result));
35063 return resultobj;
35064 fail:
35065 return NULL;
35066 }
35067
35068
35069 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35070 PyObject *resultobj = 0;
35071 wxDisplay *arg1 = (wxDisplay *) 0 ;
35072 bool result;
35073 void *argp1 = 0 ;
35074 int res1 = 0 ;
35075 PyObject *swig_obj[1] ;
35076
35077 if (!args) SWIG_fail;
35078 swig_obj[0] = args;
35079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35082 }
35083 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35084 {
35085 PyThreadState* __tstate = wxPyBeginAllowThreads();
35086 result = (bool)((wxDisplay const *)arg1)->IsOk();
35087 wxPyEndAllowThreads(__tstate);
35088 if (PyErr_Occurred()) SWIG_fail;
35089 }
35090 {
35091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35092 }
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35100 PyObject *resultobj = 0;
35101 wxDisplay *arg1 = (wxDisplay *) 0 ;
35102 wxRect result;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 PyObject *swig_obj[1] ;
35106
35107 if (!args) SWIG_fail;
35108 swig_obj[0] = args;
35109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35112 }
35113 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = ((wxDisplay const *)arg1)->GetGeometry();
35117 wxPyEndAllowThreads(__tstate);
35118 if (PyErr_Occurred()) SWIG_fail;
35119 }
35120 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35121 return resultobj;
35122 fail:
35123 return NULL;
35124 }
35125
35126
35127 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35128 PyObject *resultobj = 0;
35129 wxDisplay *arg1 = (wxDisplay *) 0 ;
35130 wxRect result;
35131 void *argp1 = 0 ;
35132 int res1 = 0 ;
35133 PyObject *swig_obj[1] ;
35134
35135 if (!args) SWIG_fail;
35136 swig_obj[0] = args;
35137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35138 if (!SWIG_IsOK(res1)) {
35139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35140 }
35141 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 result = ((wxDisplay const *)arg1)->GetClientArea();
35145 wxPyEndAllowThreads(__tstate);
35146 if (PyErr_Occurred()) SWIG_fail;
35147 }
35148 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35149 return resultobj;
35150 fail:
35151 return NULL;
35152 }
35153
35154
35155 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35156 PyObject *resultobj = 0;
35157 wxDisplay *arg1 = (wxDisplay *) 0 ;
35158 wxString result;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 PyObject *swig_obj[1] ;
35162
35163 if (!args) SWIG_fail;
35164 swig_obj[0] = args;
35165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35166 if (!SWIG_IsOK(res1)) {
35167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35168 }
35169 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 result = ((wxDisplay const *)arg1)->GetName();
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 {
35177 #if wxUSE_UNICODE
35178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35179 #else
35180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35181 #endif
35182 }
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *resultobj = 0;
35191 wxDisplay *arg1 = (wxDisplay *) 0 ;
35192 bool result;
35193 void *argp1 = 0 ;
35194 int res1 = 0 ;
35195 PyObject *swig_obj[1] ;
35196
35197 if (!args) SWIG_fail;
35198 swig_obj[0] = args;
35199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35200 if (!SWIG_IsOK(res1)) {
35201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35202 }
35203 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35207 wxPyEndAllowThreads(__tstate);
35208 if (PyErr_Occurred()) SWIG_fail;
35209 }
35210 {
35211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35212 }
35213 return resultobj;
35214 fail:
35215 return NULL;
35216 }
35217
35218
35219 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35220 PyObject *resultobj = 0;
35221 wxDisplay *arg1 = (wxDisplay *) 0 ;
35222 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35223 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35224 PyObject *result = 0 ;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 void *argp2 = 0 ;
35228 int res2 = 0 ;
35229 PyObject * obj0 = 0 ;
35230 PyObject * obj1 = 0 ;
35231 char * kwnames[] = {
35232 (char *) "self",(char *) "mode", NULL
35233 };
35234
35235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35239 }
35240 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35241 if (obj1) {
35242 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35243 if (!SWIG_IsOK(res2)) {
35244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35245 }
35246 if (!argp2) {
35247 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35248 }
35249 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35250 }
35251 {
35252 PyThreadState* __tstate = wxPyBeginAllowThreads();
35253 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 resultobj = result;
35258 return resultobj;
35259 fail:
35260 return NULL;
35261 }
35262
35263
35264 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35265 PyObject *resultobj = 0;
35266 wxDisplay *arg1 = (wxDisplay *) 0 ;
35267 wxVideoMode result;
35268 void *argp1 = 0 ;
35269 int res1 = 0 ;
35270 PyObject *swig_obj[1] ;
35271
35272 if (!args) SWIG_fail;
35273 swig_obj[0] = args;
35274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35275 if (!SWIG_IsOK(res1)) {
35276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35277 }
35278 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj = 0;
35294 wxDisplay *arg1 = (wxDisplay *) 0 ;
35295 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35296 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35297 bool result;
35298 void *argp1 = 0 ;
35299 int res1 = 0 ;
35300 void *argp2 = 0 ;
35301 int res2 = 0 ;
35302 PyObject * obj0 = 0 ;
35303 PyObject * obj1 = 0 ;
35304 char * kwnames[] = {
35305 (char *) "self",(char *) "mode", NULL
35306 };
35307
35308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35310 if (!SWIG_IsOK(res1)) {
35311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35312 }
35313 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35314 if (obj1) {
35315 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35316 if (!SWIG_IsOK(res2)) {
35317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35318 }
35319 if (!argp2) {
35320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35321 }
35322 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35323 }
35324 {
35325 PyThreadState* __tstate = wxPyBeginAllowThreads();
35326 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35327 wxPyEndAllowThreads(__tstate);
35328 if (PyErr_Occurred()) SWIG_fail;
35329 }
35330 {
35331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35332 }
35333 return resultobj;
35334 fail:
35335 return NULL;
35336 }
35337
35338
35339 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35340 PyObject *resultobj = 0;
35341 wxDisplay *arg1 = (wxDisplay *) 0 ;
35342 void *argp1 = 0 ;
35343 int res1 = 0 ;
35344 PyObject *swig_obj[1] ;
35345
35346 if (!args) SWIG_fail;
35347 swig_obj[0] = args;
35348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35349 if (!SWIG_IsOK(res1)) {
35350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35351 }
35352 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35353 {
35354 PyThreadState* __tstate = wxPyBeginAllowThreads();
35355 wxDisplay_ResetMode(arg1);
35356 wxPyEndAllowThreads(__tstate);
35357 if (PyErr_Occurred()) SWIG_fail;
35358 }
35359 resultobj = SWIG_Py_Void();
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35367 PyObject *obj;
35368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35369 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35370 return SWIG_Py_Void();
35371 }
35372
35373 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 return SWIG_Python_InitShadowInstance(args);
35375 }
35376
35377 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35378 PyObject *resultobj = 0;
35379 wxStandardPaths *result = 0 ;
35380
35381 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 result = (wxStandardPaths *)wxStandardPaths_Get();
35385 wxPyEndAllowThreads(__tstate);
35386 if (PyErr_Occurred()) SWIG_fail;
35387 }
35388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35396 PyObject *resultobj = 0;
35397 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35398 wxString result;
35399 void *argp1 = 0 ;
35400 int res1 = 0 ;
35401 PyObject *swig_obj[1] ;
35402
35403 if (!args) SWIG_fail;
35404 swig_obj[0] = args;
35405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35406 if (!SWIG_IsOK(res1)) {
35407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35408 }
35409 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35410 {
35411 PyThreadState* __tstate = wxPyBeginAllowThreads();
35412 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35413 wxPyEndAllowThreads(__tstate);
35414 if (PyErr_Occurred()) SWIG_fail;
35415 }
35416 {
35417 #if wxUSE_UNICODE
35418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35419 #else
35420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35421 #endif
35422 }
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35430 PyObject *resultobj = 0;
35431 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35432 wxString result;
35433 void *argp1 = 0 ;
35434 int res1 = 0 ;
35435 PyObject *swig_obj[1] ;
35436
35437 if (!args) SWIG_fail;
35438 swig_obj[0] = args;
35439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35442 }
35443 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35444 {
35445 PyThreadState* __tstate = wxPyBeginAllowThreads();
35446 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 {
35451 #if wxUSE_UNICODE
35452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35453 #else
35454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35455 #endif
35456 }
35457 return resultobj;
35458 fail:
35459 return NULL;
35460 }
35461
35462
35463 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35464 PyObject *resultobj = 0;
35465 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35466 wxString result;
35467 void *argp1 = 0 ;
35468 int res1 = 0 ;
35469 PyObject *swig_obj[1] ;
35470
35471 if (!args) SWIG_fail;
35472 swig_obj[0] = args;
35473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35474 if (!SWIG_IsOK(res1)) {
35475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35476 }
35477 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 {
35485 #if wxUSE_UNICODE
35486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35487 #else
35488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35489 #endif
35490 }
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35498 PyObject *resultobj = 0;
35499 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35500 wxString result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35510 }
35511 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 #if wxUSE_UNICODE
35520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35521 #else
35522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35523 #endif
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35532 PyObject *resultobj = 0;
35533 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35534 wxString result;
35535 void *argp1 = 0 ;
35536 int res1 = 0 ;
35537 PyObject *swig_obj[1] ;
35538
35539 if (!args) SWIG_fail;
35540 swig_obj[0] = args;
35541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35544 }
35545 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 #if wxUSE_UNICODE
35554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35555 #else
35556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35557 #endif
35558 }
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(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_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
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_GetPluginsDir(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_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35612 }
35613 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
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_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35634 PyObject *resultobj = 0;
35635 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35636 wxString *arg2 = 0 ;
35637 void *argp1 = 0 ;
35638 int res1 = 0 ;
35639 bool temp2 = false ;
35640 PyObject * obj0 = 0 ;
35641 PyObject * obj1 = 0 ;
35642 char * kwnames[] = {
35643 (char *) "self",(char *) "prefix", NULL
35644 };
35645
35646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35648 if (!SWIG_IsOK(res1)) {
35649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35650 }
35651 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35652 {
35653 arg2 = wxString_in_helper(obj1);
35654 if (arg2 == NULL) SWIG_fail;
35655 temp2 = true;
35656 }
35657 {
35658 PyThreadState* __tstate = wxPyBeginAllowThreads();
35659 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 resultobj = SWIG_Py_Void();
35664 {
35665 if (temp2)
35666 delete arg2;
35667 }
35668 return resultobj;
35669 fail:
35670 {
35671 if (temp2)
35672 delete arg2;
35673 }
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35679 PyObject *resultobj = 0;
35680 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35681 wxString result;
35682 void *argp1 = 0 ;
35683 int res1 = 0 ;
35684 PyObject *swig_obj[1] ;
35685
35686 if (!args) SWIG_fail;
35687 swig_obj[0] = args;
35688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35689 if (!SWIG_IsOK(res1)) {
35690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35691 }
35692 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 {
35700 #if wxUSE_UNICODE
35701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35702 #else
35703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35704 #endif
35705 }
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35713 PyObject *obj;
35714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35715 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35716 return SWIG_Py_Void();
35717 }
35718
35719 static PyMethodDef SwigMethods[] = {
35720 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35721 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35722 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35723 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35724 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35725 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35726 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35727 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35728 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35729 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35730 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35731 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35732 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35733 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35734 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35735 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35736 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35737 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35738 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35739 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35740 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35741 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35742 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35743 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35744 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35745 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35746 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35747 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35748 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35749 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35750 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35751 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35752 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35753 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35754 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35755 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35756 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35757 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35758 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35759 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35760 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35761 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35762 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35763 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35764 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35765 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35766 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35767 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35768 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35769 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35770 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35771 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35772 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35773 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35774 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35775 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35776 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35777 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35778 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35779 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35780 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35781 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35782 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35783 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35784 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35785 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35786 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35787 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35788 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35789 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
35790 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
35791 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35792 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35793 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
35794 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
35795 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
35796 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
35797 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
35798 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
35799 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
35800 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
35801 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
35802 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
35803 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
35804 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
35805 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
35806 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
35807 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
35808 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
35809 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
35810 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35811 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
35812 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
35813 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
35814 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35815 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
35816 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
35817 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
35818 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
35819 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
35820 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
35821 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
35822 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
35823 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
35824 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
35825 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
35826 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
35827 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
35828 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35829 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
35830 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
35831 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
35832 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
35833 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35834 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
35835 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
35836 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
35837 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
35838 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
35839 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
35840 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
35841 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
35842 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
35843 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
35844 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
35845 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
35846 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
35847 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
35848 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35849 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
35850 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35851 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35852 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
35853 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
35854 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
35855 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
35856 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
35857 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35858 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
35859 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
35860 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
35861 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
35862 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
35863 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
35864 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
35865 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35866 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
35867 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
35868 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
35869 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
35870 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35871 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
35872 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
35873 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
35874 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
35875 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
35876 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35877 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
35878 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35879 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35880 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
35881 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35882 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35883 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
35884 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
35885 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
35886 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35887 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
35888 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
35889 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
35890 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
35891 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
35892 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
35893 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
35894 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35895 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
35896 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
35897 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
35898 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
35899 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
35900 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
35901 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
35902 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
35903 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
35904 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35905 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35906 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
35907 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
35908 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
35909 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35910 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
35911 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
35912 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35913 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
35914 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
35915 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35916 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
35917 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
35918 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
35919 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
35920 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
35921 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
35922 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
35923 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
35924 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35925 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
35926 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
35927 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
35928 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
35929 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
35930 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35931 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
35932 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
35933 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
35934 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
35935 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
35936 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
35937 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
35938 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
35939 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
35940 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
35941 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35942 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
35943 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
35944 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
35945 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
35946 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
35947 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35948 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35949 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35950 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
35951 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
35952 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
35953 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
35954 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
35955 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35956 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
35957 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
35958 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
35959 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
35960 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
35961 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
35962 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
35963 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
35964 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
35965 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35966 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
35967 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
35968 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
35969 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
35970 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
35971 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35972 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35973 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
35974 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
35975 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
35976 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
35977 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
35978 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
35979 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
35980 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
35981 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
35982 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
35983 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
35984 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
35985 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
35986 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
35987 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
35988 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
35989 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
35990 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
35991 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
35993 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
35994 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
35995 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
35996 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35997 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
35998 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
35999 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36000 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36001 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36002 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36004 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36005 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36006 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36007 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36008 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36009 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36010 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36011 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36012 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36013 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36014 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36015 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36016 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36017 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36018 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36019 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36020 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36021 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36022 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36023 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36024 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36025 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36026 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36027 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36028 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36029 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36030 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36031 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36032 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36033 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36034 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36035 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36036 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36037 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36038 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36039 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36040 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36042 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36044 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36045 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36046 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36047 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36048 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36049 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36050 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36051 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36052 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36053 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36054 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36055 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36056 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36057 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36058 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36059 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36060 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36061 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36062 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36063 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36064 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36065 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36066 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36067 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36068 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36069 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36070 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36071 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36072 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36073 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36074 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36075 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36076 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36077 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36078 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36079 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36080 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36081 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36082 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36083 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36084 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36086 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36087 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36088 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36090 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36091 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36092 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36093 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36094 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36095 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36098 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36099 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36100 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36101 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36102 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36103 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36106 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36107 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36109 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36110 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36111 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36112 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36113 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36114 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36116 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36117 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36118 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36121 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36122 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36123 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36124 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36125 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36126 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36127 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36128 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36129 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36130 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36131 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36132 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36133 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36134 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36135 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36136 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36137 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36138 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36139 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36140 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36141 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36142 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36143 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36144 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36145 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36148 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36149 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36151 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36152 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36154 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36156 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36161 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36163 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36164 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36165 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36166 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36167 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36168 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36169 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36170 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36171 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36172 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36174 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36177 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36178 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36179 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36180 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36183 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36184 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36186 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36187 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36188 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36189 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36191 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36193 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36194 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36195 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36198 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36199 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36210 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36212 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36214 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36216 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36217 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36221 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36222 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36224 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36225 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36226 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36228 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36229 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36230 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36231 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36232 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36233 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36234 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36235 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36238 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36239 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36249 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36253 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36254 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36255 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36256 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36260 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36262 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36263 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36268 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36275 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36289 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36291 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36292 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36293 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36294 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36295 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36296 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36297 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36308 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36309 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36310 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36335 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36336 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36337 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36338 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36350 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36351 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36352 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36353 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36354 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36355 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36356 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36358 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36360 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36362 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36364 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36366 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36368 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36372 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36373 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36377 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36387 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36388 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36389 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36390 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36394 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36395 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36396 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36397 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36398 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36399 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36401 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36402 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36404 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36406 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36408 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36410 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36412 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36417 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36418 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36419 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36420 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36421 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36424 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36428 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36436 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36437 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36438 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36439 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36440 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36441 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36444 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36445 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36446 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36448 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36449 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36451 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36452 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36453 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36461 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36463 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36465 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36466 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36468 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36469 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36472 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36473 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36474 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36476 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36477 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36479 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36480 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36482 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36483 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36486 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36487 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36489 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36491 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36492 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36495 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36496 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36497 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36498 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36500 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36501 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36502 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36503 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36504 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36505 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36506 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36507 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36508 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36509 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36511 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36512 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36513 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36514 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36515 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36519 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36521 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36525 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36526 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36529 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36530 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36534 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36536 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36538 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36539 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36540 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36541 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36546 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36549 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36550 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36551 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36556 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36559 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36560 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36561 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36562 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36563 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36564 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36565 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36570 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36571 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36573 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36574 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36575 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36577 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36578 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36579 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36580 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36582 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36584 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36585 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36586 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36587 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36590 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36591 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36592 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36593 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36594 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36595 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36596 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36597 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36598 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36599 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36601 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36602 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36605 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36606 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36607 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36608 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36609 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36611 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36613 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36614 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36615 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36616 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36617 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36618 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36619 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36620 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36621 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36622 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36623 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36625 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36626 { NULL, NULL, 0, NULL }
36627 };
36628
36629
36630 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36631
36632 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36633 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36634 }
36635 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36636 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36637 }
36638 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36639 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36640 }
36641 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36642 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36643 }
36644 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36645 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36646 }
36647 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36648 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36649 }
36650 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36651 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36652 }
36653 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36654 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36655 }
36656 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36657 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36658 }
36659 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36660 return (void *)((wxEvent *) ((wxPyEvent *) x));
36661 }
36662 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36663 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36664 }
36665 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36666 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36667 }
36668 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36669 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36670 }
36671 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36672 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36673 }
36674 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36675 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36676 }
36677 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36678 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36679 }
36680 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36681 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36682 }
36683 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36684 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36685 }
36686 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36687 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36688 }
36689 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36690 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36691 }
36692 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36693 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36694 }
36695 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36696 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36697 }
36698 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36699 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36700 }
36701 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36702 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36703 }
36704 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36705 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36706 }
36707 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36708 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36709 }
36710 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36711 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36712 }
36713 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36714 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36715 }
36716 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36717 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36718 }
36719 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36720 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36721 }
36722 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36723 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36724 }
36725 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36726 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36727 }
36728 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36729 return (void *)((wxEvent *) ((wxShowEvent *) x));
36730 }
36731 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36732 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36733 }
36734 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36735 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36736 }
36737 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36739 }
36740 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36741 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36742 }
36743 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36744 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36745 }
36746 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36747 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36748 }
36749 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36750 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36751 }
36752 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36753 return (void *)((wxConfigBase *) ((wxConfig *) x));
36754 }
36755 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36756 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36757 }
36758 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36759 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36760 }
36761 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36762 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36763 }
36764 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36765 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36766 }
36767 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36768 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36769 }
36770 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36771 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36772 }
36773 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36774 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36775 }
36776 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36777 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36778 }
36779 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36780 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36781 }
36782 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
36783 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
36784 }
36785 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
36786 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
36787 }
36788 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
36789 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
36790 }
36791 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
36792 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36793 }
36794 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
36795 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36796 }
36797 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36798 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
36799 }
36800 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36801 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
36802 }
36803 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36804 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36805 }
36806 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36807 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36808 }
36809 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
36810 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
36811 }
36812 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
36813 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
36814 }
36815 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
36816 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36817 }
36818 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
36819 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
36820 }
36821 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
36822 return (void *)((wxEvtHandler *) ((wxWindow *) x));
36823 }
36824 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
36825 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36826 }
36827 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
36828 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
36829 }
36830 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
36831 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
36832 }
36833 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
36834 return (void *)((wxEvtHandler *) ((wxValidator *) x));
36835 }
36836 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
36837 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
36838 }
36839 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
36840 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
36841 }
36842 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
36843 return (void *)((wxEvtHandler *) ((wxMenu *) x));
36844 }
36845 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
36846 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
36847 }
36848 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
36849 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
36850 }
36851 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36852 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
36853 }
36854 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36855 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36856 }
36857 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36858 return (void *)((wxObject *) ((wxSizerItem *) x));
36859 }
36860 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36861 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36862 }
36863 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36864 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
36865 }
36866 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36867 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36868 }
36869 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36870 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36871 }
36872 static void *_p_wxSizerTo_p_wxObject(void *x) {
36873 return (void *)((wxObject *) ((wxSizer *) x));
36874 }
36875 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36876 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36877 }
36878 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
36879 return (void *)((wxObject *) ((wxFileHistory *) x));
36880 }
36881 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36882 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36883 }
36884 static void *_p_wxEventTo_p_wxObject(void *x) {
36885 return (void *)((wxObject *) ((wxEvent *) x));
36886 }
36887 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36888 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36889 }
36890 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36891 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36892 }
36893 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36894 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36895 }
36896 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36897 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36898 }
36899 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36900 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36901 }
36902 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36903 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36904 }
36905 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36906 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36907 }
36908 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36909 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36910 }
36911 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36912 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36913 }
36914 static void *_p_wxControlTo_p_wxObject(void *x) {
36915 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36916 }
36917 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36918 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36919 }
36920 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
36921 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
36922 }
36923 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36924 return (void *)((wxObject *) ((wxFSFile *) x));
36925 }
36926 static void *_p_wxClipboardTo_p_wxObject(void *x) {
36927 return (void *)((wxObject *) ((wxClipboard *) x));
36928 }
36929 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36930 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36931 }
36932 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36933 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36934 }
36935 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36936 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
36937 }
36938 static void *_p_wxShowEventTo_p_wxObject(void *x) {
36939 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
36940 }
36941 static void *_p_wxToolTipTo_p_wxObject(void *x) {
36942 return (void *)((wxObject *) ((wxToolTip *) x));
36943 }
36944 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
36945 return (void *)((wxObject *) ((wxMenuItem *) x));
36946 }
36947 static void *_p_wxDateEventTo_p_wxObject(void *x) {
36948 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
36949 }
36950 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
36951 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
36952 }
36953 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
36954 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
36955 }
36956 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
36957 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
36958 }
36959 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
36960 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
36961 }
36962 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
36963 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
36964 }
36965 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
36966 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
36967 }
36968 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
36969 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
36970 }
36971 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
36972 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
36973 }
36974 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
36975 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
36976 }
36977 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
36978 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
36979 }
36980 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
36981 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
36982 }
36983 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
36984 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
36985 }
36986 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
36987 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
36988 }
36989 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
36990 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
36991 }
36992 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
36993 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
36994 }
36995 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
36996 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
36997 }
36998 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
36999 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37000 }
37001 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37002 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37003 }
37004 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37005 return (void *)((wxObject *) ((wxImageHandler *) x));
37006 }
37007 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37008 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37009 }
37010 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37011 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37012 }
37013 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37014 return (void *)((wxObject *) ((wxEvtHandler *) x));
37015 }
37016 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37017 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37018 }
37019 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37020 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37021 }
37022 static void *_p_wxImageTo_p_wxObject(void *x) {
37023 return (void *)((wxObject *) ((wxImage *) x));
37024 }
37025 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37026 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37027 }
37028 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37029 return (void *)((wxObject *) ((wxSystemOptions *) x));
37030 }
37031 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37032 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37033 }
37034 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37035 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37036 }
37037 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37038 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37039 }
37040 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37041 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37042 }
37043 static void *_p_wxWindowTo_p_wxObject(void *x) {
37044 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37045 }
37046 static void *_p_wxMenuTo_p_wxObject(void *x) {
37047 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37048 }
37049 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37050 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37051 }
37052 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37053 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37054 }
37055 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37056 return (void *)((wxObject *) ((wxFileSystem *) x));
37057 }
37058 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37059 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37060 }
37061 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37062 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37063 }
37064 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37065 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37066 }
37067 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37068 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37069 }
37070 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37071 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37072 }
37073 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37074 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37075 }
37076 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37077 return (void *)((wxObject *) ((wxBusyInfo *) x));
37078 }
37079 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37080 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37081 }
37082 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37083 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37084 }
37085 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37086 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37087 }
37088 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37089 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37090 }
37091 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37092 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37093 }
37094 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37095 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37096 }
37097 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37098 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37099 }
37100 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37101 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37102 }
37103 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37104 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37105 }
37106 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37107 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37108 }
37109 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37110 return (void *)((wxLog *) ((wxLogBuffer *) x));
37111 }
37112 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37113 return (void *)((wxLog *) ((wxLogStderr *) x));
37114 }
37115 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37116 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37117 }
37118 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37119 return (void *)((wxLog *) ((wxLogWindow *) x));
37120 }
37121 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37122 return (void *)((wxLog *) ((wxLogChain *) x));
37123 }
37124 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37125 return (void *)((wxLog *) ((wxLogGui *) x));
37126 }
37127 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37128 return (void *)((wxLog *) ((wxPyLog *) x));
37129 }
37130 static void *_p_wxControlTo_p_wxWindow(void *x) {
37131 return (void *)((wxWindow *) ((wxControl *) x));
37132 }
37133 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37134 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37135 }
37136 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37137 return (void *)((wxWindow *) ((wxMenuBar *) x));
37138 }
37139 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37140 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37141 }
37142 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37143 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37144 }
37145 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37146 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};
37147 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37148 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37149 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37150 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37151 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37152 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37153 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37154 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37155 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37156 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37157 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37158 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37159 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37160 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37161 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37162 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37163 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37164 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37165 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37166 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37167 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37168 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37169 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37170 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37171 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37172 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37173 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37174 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37175 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37176 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37177 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37178 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37179 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37180 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37181 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37182 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37183 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37184 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37185 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37186 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37187 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37188 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37189 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37190 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37191 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37192 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37193 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37194 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37195 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37196 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37197 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37198 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37199 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37200 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37201 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37202 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37203 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37204 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37205 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37206 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37207 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37208 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37209 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37210 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37211 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37212 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37213 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37214 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37215 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37216 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37217 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37218 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37219 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37220 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37221 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37222 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37223 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37224 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37225 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37226 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37227 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37228 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37229 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37230 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37231 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37232 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37233 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37234 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37235 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37236 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37237 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37238 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37239 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37240 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37241 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37242 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37243 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37244 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37245 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37246 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37247 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37248 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37249 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37250 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37251 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37252 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37253 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37254 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37255 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37256 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37257 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37258 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37259 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37260 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37261 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37262 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37263 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37264 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37265 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37266 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37267 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37268 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37269 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37270 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37271 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37272 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37273 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37274 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37275 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37276 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37277 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37278 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37279 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37280 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37281 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37282 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37283 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37284 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37285 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37286 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37287 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37288 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37289 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37290 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37291 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37292 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37293 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37294 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37295 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37296 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37297 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37298 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37299 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37300 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37301 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37302 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37303 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37304 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37305 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37306 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37307 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37308 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37309 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37310 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37311 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37312 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37313 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37314
37315 static swig_type_info *swig_type_initial[] = {
37316 &_swigt__p_char,
37317 &_swigt__p_form_ops_t,
37318 &_swigt__p_int,
37319 &_swigt__p_unsigned_char,
37320 &_swigt__p_unsigned_int,
37321 &_swigt__p_unsigned_long,
37322 &_swigt__p_void,
37323 &_swigt__p_wxANIHandler,
37324 &_swigt__p_wxAcceleratorTable,
37325 &_swigt__p_wxActivateEvent,
37326 &_swigt__p_wxArrayString,
37327 &_swigt__p_wxBMPHandler,
37328 &_swigt__p_wxBitmap,
37329 &_swigt__p_wxBitmapDataObject,
37330 &_swigt__p_wxBoxSizer,
37331 &_swigt__p_wxBusyCursor,
37332 &_swigt__p_wxBusyInfo,
37333 &_swigt__p_wxCURHandler,
37334 &_swigt__p_wxCaret,
37335 &_swigt__p_wxChar,
37336 &_swigt__p_wxChildFocusEvent,
37337 &_swigt__p_wxClipboard,
37338 &_swigt__p_wxClipboardLocker,
37339 &_swigt__p_wxCloseEvent,
37340 &_swigt__p_wxColour,
37341 &_swigt__p_wxCommandEvent,
37342 &_swigt__p_wxConfig,
37343 &_swigt__p_wxConfigBase,
37344 &_swigt__p_wxConfigPathChanger,
37345 &_swigt__p_wxContextMenuEvent,
37346 &_swigt__p_wxControl,
37347 &_swigt__p_wxControlWithItems,
37348 &_swigt__p_wxCursor,
37349 &_swigt__p_wxCustomDataObject,
37350 &_swigt__p_wxDC,
37351 &_swigt__p_wxDataFormat,
37352 &_swigt__p_wxDataObject,
37353 &_swigt__p_wxDataObjectComposite,
37354 &_swigt__p_wxDataObjectSimple,
37355 &_swigt__p_wxDateEvent,
37356 &_swigt__p_wxDateSpan,
37357 &_swigt__p_wxDateTime,
37358 &_swigt__p_wxDateTime__TimeZone,
37359 &_swigt__p_wxDisplay,
37360 &_swigt__p_wxDisplayChangedEvent,
37361 &_swigt__p_wxDropFilesEvent,
37362 &_swigt__p_wxDuplexMode,
37363 &_swigt__p_wxEraseEvent,
37364 &_swigt__p_wxEvent,
37365 &_swigt__p_wxEvtHandler,
37366 &_swigt__p_wxFSFile,
37367 &_swigt__p_wxFileConfig,
37368 &_swigt__p_wxFileDataObject,
37369 &_swigt__p_wxFileHistory,
37370 &_swigt__p_wxFileSystem,
37371 &_swigt__p_wxFileType,
37372 &_swigt__p_wxFileTypeInfo,
37373 &_swigt__p_wxFlexGridSizer,
37374 &_swigt__p_wxFocusEvent,
37375 &_swigt__p_wxFont,
37376 &_swigt__p_wxFrame,
37377 &_swigt__p_wxGBSizerItem,
37378 &_swigt__p_wxGIFHandler,
37379 &_swigt__p_wxGridBagSizer,
37380 &_swigt__p_wxGridSizer,
37381 &_swigt__p_wxICOHandler,
37382 &_swigt__p_wxIcon,
37383 &_swigt__p_wxIconizeEvent,
37384 &_swigt__p_wxIdleEvent,
37385 &_swigt__p_wxImage,
37386 &_swigt__p_wxImageHandler,
37387 &_swigt__p_wxIndividualLayoutConstraint,
37388 &_swigt__p_wxInitDialogEvent,
37389 &_swigt__p_wxJPEGHandler,
37390 &_swigt__p_wxJoystick,
37391 &_swigt__p_wxJoystickEvent,
37392 &_swigt__p_wxKeyEvent,
37393 &_swigt__p_wxKillError,
37394 &_swigt__p_wxLayoutConstraints,
37395 &_swigt__p_wxLog,
37396 &_swigt__p_wxLogBuffer,
37397 &_swigt__p_wxLogChain,
37398 &_swigt__p_wxLogGui,
37399 &_swigt__p_wxLogNull,
37400 &_swigt__p_wxLogStderr,
37401 &_swigt__p_wxLogTextCtrl,
37402 &_swigt__p_wxLogWindow,
37403 &_swigt__p_wxMaximizeEvent,
37404 &_swigt__p_wxMemorySize,
37405 &_swigt__p_wxMenu,
37406 &_swigt__p_wxMenuBar,
37407 &_swigt__p_wxMenuEvent,
37408 &_swigt__p_wxMenuItem,
37409 &_swigt__p_wxMetafileDataObject,
37410 &_swigt__p_wxMimeTypesManager,
37411 &_swigt__p_wxMouseCaptureChangedEvent,
37412 &_swigt__p_wxMouseEvent,
37413 &_swigt__p_wxMouseState,
37414 &_swigt__p_wxMoveEvent,
37415 &_swigt__p_wxMutexGuiLocker,
37416 &_swigt__p_wxNavigationKeyEvent,
37417 &_swigt__p_wxNcPaintEvent,
37418 &_swigt__p_wxNotifyEvent,
37419 &_swigt__p_wxObject,
37420 &_swigt__p_wxOutputStream,
37421 &_swigt__p_wxPCXHandler,
37422 &_swigt__p_wxPNGHandler,
37423 &_swigt__p_wxPNMHandler,
37424 &_swigt__p_wxPaintEvent,
37425 &_swigt__p_wxPaletteChangedEvent,
37426 &_swigt__p_wxPaperSize,
37427 &_swigt__p_wxPoint,
37428 &_swigt__p_wxProcessEvent,
37429 &_swigt__p_wxPyApp,
37430 &_swigt__p_wxPyArtProvider,
37431 &_swigt__p_wxPyBitmapDataObject,
37432 &_swigt__p_wxPyCommandEvent,
37433 &_swigt__p_wxPyDataObjectSimple,
37434 &_swigt__p_wxPyDropSource,
37435 &_swigt__p_wxPyDropTarget,
37436 &_swigt__p_wxPyEvent,
37437 &_swigt__p_wxPyFileDropTarget,
37438 &_swigt__p_wxPyImageHandler,
37439 &_swigt__p_wxPyLog,
37440 &_swigt__p_wxPyProcess,
37441 &_swigt__p_wxPySizer,
37442 &_swigt__p_wxPyTextDataObject,
37443 &_swigt__p_wxPyTextDropTarget,
37444 &_swigt__p_wxPyTimer,
37445 &_swigt__p_wxPyTipProvider,
37446 &_swigt__p_wxPyValidator,
37447 &_swigt__p_wxQueryNewPaletteEvent,
37448 &_swigt__p_wxRect,
37449 &_swigt__p_wxScrollEvent,
37450 &_swigt__p_wxScrollWinEvent,
37451 &_swigt__p_wxSetCursorEvent,
37452 &_swigt__p_wxShowEvent,
37453 &_swigt__p_wxSingleInstanceChecker,
37454 &_swigt__p_wxSize,
37455 &_swigt__p_wxSizeEvent,
37456 &_swigt__p_wxSizer,
37457 &_swigt__p_wxSizerItem,
37458 &_swigt__p_wxSound,
37459 &_swigt__p_wxStandardPaths,
37460 &_swigt__p_wxStaticBoxSizer,
37461 &_swigt__p_wxStdDialogButtonSizer,
37462 &_swigt__p_wxStopWatch,
37463 &_swigt__p_wxString,
37464 &_swigt__p_wxSysColourChangedEvent,
37465 &_swigt__p_wxSystemOptions,
37466 &_swigt__p_wxSystemSettings,
37467 &_swigt__p_wxTIFFHandler,
37468 &_swigt__p_wxTextCtrl,
37469 &_swigt__p_wxTextDataObject,
37470 &_swigt__p_wxTimeSpan,
37471 &_swigt__p_wxTimer,
37472 &_swigt__p_wxTimerEvent,
37473 &_swigt__p_wxTimerRunner,
37474 &_swigt__p_wxTipProvider,
37475 &_swigt__p_wxToolTip,
37476 &_swigt__p_wxURLDataObject,
37477 &_swigt__p_wxUpdateUIEvent,
37478 &_swigt__p_wxValidator,
37479 &_swigt__p_wxVideoMode,
37480 &_swigt__p_wxWindow,
37481 &_swigt__p_wxWindowCreateEvent,
37482 &_swigt__p_wxWindowDestroyEvent,
37483 &_swigt__p_wxWindowDisabler,
37484 &_swigt__p_wxXPMHandler,
37485 };
37486
37487 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37488 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37489 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37490 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37491 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37492 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37493 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37494 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37495 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37496 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}};
37497 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37498 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37499 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37500 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37501 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37502 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37503 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37504 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37505 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}};
37506 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37507 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37508 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37509 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37510 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37511 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}};
37512 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37513 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}};
37514 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37515 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37516 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37517 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37518 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37519 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37520 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37521 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37522 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37523 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37524 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37525 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37526 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37527 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37528 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37529 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37530 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37531 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37532 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37533 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37534 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37535 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37536 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37537 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37538 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37539 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37540 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37541 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37542 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37543 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37544 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37545 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37546 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37547 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37548 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37549 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37550 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37551 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37552 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37553 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37554 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37555 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_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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}};
37556 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37557 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37558 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37559 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37560 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37561 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37562 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}};
37563 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37564 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37565 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37566 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37567 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37568 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37569 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37570 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37571 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37572 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37573 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37574 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}};
37575 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37576 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37577 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37578 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37579 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37580 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37581 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37582 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37583 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37584 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37585 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37586 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37587 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37588 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37589 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37590 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37591 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37592 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37593 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37594 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37595 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37596 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37597 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37598 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37599 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37600 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37601 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37602 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37603 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37604 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37605 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37606 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37607 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37608 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37609 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37610 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37611 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37612 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37613 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37614 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37615 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37616 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37617 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37618 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_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_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_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_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_wxProcessEvent, _p_wxProcessEventTo_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}};
37619 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37620 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37621 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37622 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37623 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37624 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37625 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37626 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37627 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}};
37628 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37629 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37630 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37631 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37632 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37633 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37634 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37635 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37636 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37637 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37638 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37639 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37640 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37641 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37642 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37643 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37644 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37645 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}};
37646 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37647 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37648 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37649 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37650 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}};
37651 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37652 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37653 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37654 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}};
37655 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37656
37657 static swig_cast_info *swig_cast_initial[] = {
37658 _swigc__p_char,
37659 _swigc__p_form_ops_t,
37660 _swigc__p_int,
37661 _swigc__p_unsigned_char,
37662 _swigc__p_unsigned_int,
37663 _swigc__p_unsigned_long,
37664 _swigc__p_void,
37665 _swigc__p_wxANIHandler,
37666 _swigc__p_wxAcceleratorTable,
37667 _swigc__p_wxActivateEvent,
37668 _swigc__p_wxArrayString,
37669 _swigc__p_wxBMPHandler,
37670 _swigc__p_wxBitmap,
37671 _swigc__p_wxBitmapDataObject,
37672 _swigc__p_wxBoxSizer,
37673 _swigc__p_wxBusyCursor,
37674 _swigc__p_wxBusyInfo,
37675 _swigc__p_wxCURHandler,
37676 _swigc__p_wxCaret,
37677 _swigc__p_wxChar,
37678 _swigc__p_wxChildFocusEvent,
37679 _swigc__p_wxClipboard,
37680 _swigc__p_wxClipboardLocker,
37681 _swigc__p_wxCloseEvent,
37682 _swigc__p_wxColour,
37683 _swigc__p_wxCommandEvent,
37684 _swigc__p_wxConfig,
37685 _swigc__p_wxConfigBase,
37686 _swigc__p_wxConfigPathChanger,
37687 _swigc__p_wxContextMenuEvent,
37688 _swigc__p_wxControl,
37689 _swigc__p_wxControlWithItems,
37690 _swigc__p_wxCursor,
37691 _swigc__p_wxCustomDataObject,
37692 _swigc__p_wxDC,
37693 _swigc__p_wxDataFormat,
37694 _swigc__p_wxDataObject,
37695 _swigc__p_wxDataObjectComposite,
37696 _swigc__p_wxDataObjectSimple,
37697 _swigc__p_wxDateEvent,
37698 _swigc__p_wxDateSpan,
37699 _swigc__p_wxDateTime,
37700 _swigc__p_wxDateTime__TimeZone,
37701 _swigc__p_wxDisplay,
37702 _swigc__p_wxDisplayChangedEvent,
37703 _swigc__p_wxDropFilesEvent,
37704 _swigc__p_wxDuplexMode,
37705 _swigc__p_wxEraseEvent,
37706 _swigc__p_wxEvent,
37707 _swigc__p_wxEvtHandler,
37708 _swigc__p_wxFSFile,
37709 _swigc__p_wxFileConfig,
37710 _swigc__p_wxFileDataObject,
37711 _swigc__p_wxFileHistory,
37712 _swigc__p_wxFileSystem,
37713 _swigc__p_wxFileType,
37714 _swigc__p_wxFileTypeInfo,
37715 _swigc__p_wxFlexGridSizer,
37716 _swigc__p_wxFocusEvent,
37717 _swigc__p_wxFont,
37718 _swigc__p_wxFrame,
37719 _swigc__p_wxGBSizerItem,
37720 _swigc__p_wxGIFHandler,
37721 _swigc__p_wxGridBagSizer,
37722 _swigc__p_wxGridSizer,
37723 _swigc__p_wxICOHandler,
37724 _swigc__p_wxIcon,
37725 _swigc__p_wxIconizeEvent,
37726 _swigc__p_wxIdleEvent,
37727 _swigc__p_wxImage,
37728 _swigc__p_wxImageHandler,
37729 _swigc__p_wxIndividualLayoutConstraint,
37730 _swigc__p_wxInitDialogEvent,
37731 _swigc__p_wxJPEGHandler,
37732 _swigc__p_wxJoystick,
37733 _swigc__p_wxJoystickEvent,
37734 _swigc__p_wxKeyEvent,
37735 _swigc__p_wxKillError,
37736 _swigc__p_wxLayoutConstraints,
37737 _swigc__p_wxLog,
37738 _swigc__p_wxLogBuffer,
37739 _swigc__p_wxLogChain,
37740 _swigc__p_wxLogGui,
37741 _swigc__p_wxLogNull,
37742 _swigc__p_wxLogStderr,
37743 _swigc__p_wxLogTextCtrl,
37744 _swigc__p_wxLogWindow,
37745 _swigc__p_wxMaximizeEvent,
37746 _swigc__p_wxMemorySize,
37747 _swigc__p_wxMenu,
37748 _swigc__p_wxMenuBar,
37749 _swigc__p_wxMenuEvent,
37750 _swigc__p_wxMenuItem,
37751 _swigc__p_wxMetafileDataObject,
37752 _swigc__p_wxMimeTypesManager,
37753 _swigc__p_wxMouseCaptureChangedEvent,
37754 _swigc__p_wxMouseEvent,
37755 _swigc__p_wxMouseState,
37756 _swigc__p_wxMoveEvent,
37757 _swigc__p_wxMutexGuiLocker,
37758 _swigc__p_wxNavigationKeyEvent,
37759 _swigc__p_wxNcPaintEvent,
37760 _swigc__p_wxNotifyEvent,
37761 _swigc__p_wxObject,
37762 _swigc__p_wxOutputStream,
37763 _swigc__p_wxPCXHandler,
37764 _swigc__p_wxPNGHandler,
37765 _swigc__p_wxPNMHandler,
37766 _swigc__p_wxPaintEvent,
37767 _swigc__p_wxPaletteChangedEvent,
37768 _swigc__p_wxPaperSize,
37769 _swigc__p_wxPoint,
37770 _swigc__p_wxProcessEvent,
37771 _swigc__p_wxPyApp,
37772 _swigc__p_wxPyArtProvider,
37773 _swigc__p_wxPyBitmapDataObject,
37774 _swigc__p_wxPyCommandEvent,
37775 _swigc__p_wxPyDataObjectSimple,
37776 _swigc__p_wxPyDropSource,
37777 _swigc__p_wxPyDropTarget,
37778 _swigc__p_wxPyEvent,
37779 _swigc__p_wxPyFileDropTarget,
37780 _swigc__p_wxPyImageHandler,
37781 _swigc__p_wxPyLog,
37782 _swigc__p_wxPyProcess,
37783 _swigc__p_wxPySizer,
37784 _swigc__p_wxPyTextDataObject,
37785 _swigc__p_wxPyTextDropTarget,
37786 _swigc__p_wxPyTimer,
37787 _swigc__p_wxPyTipProvider,
37788 _swigc__p_wxPyValidator,
37789 _swigc__p_wxQueryNewPaletteEvent,
37790 _swigc__p_wxRect,
37791 _swigc__p_wxScrollEvent,
37792 _swigc__p_wxScrollWinEvent,
37793 _swigc__p_wxSetCursorEvent,
37794 _swigc__p_wxShowEvent,
37795 _swigc__p_wxSingleInstanceChecker,
37796 _swigc__p_wxSize,
37797 _swigc__p_wxSizeEvent,
37798 _swigc__p_wxSizer,
37799 _swigc__p_wxSizerItem,
37800 _swigc__p_wxSound,
37801 _swigc__p_wxStandardPaths,
37802 _swigc__p_wxStaticBoxSizer,
37803 _swigc__p_wxStdDialogButtonSizer,
37804 _swigc__p_wxStopWatch,
37805 _swigc__p_wxString,
37806 _swigc__p_wxSysColourChangedEvent,
37807 _swigc__p_wxSystemOptions,
37808 _swigc__p_wxSystemSettings,
37809 _swigc__p_wxTIFFHandler,
37810 _swigc__p_wxTextCtrl,
37811 _swigc__p_wxTextDataObject,
37812 _swigc__p_wxTimeSpan,
37813 _swigc__p_wxTimer,
37814 _swigc__p_wxTimerEvent,
37815 _swigc__p_wxTimerRunner,
37816 _swigc__p_wxTipProvider,
37817 _swigc__p_wxToolTip,
37818 _swigc__p_wxURLDataObject,
37819 _swigc__p_wxUpdateUIEvent,
37820 _swigc__p_wxValidator,
37821 _swigc__p_wxVideoMode,
37822 _swigc__p_wxWindow,
37823 _swigc__p_wxWindowCreateEvent,
37824 _swigc__p_wxWindowDestroyEvent,
37825 _swigc__p_wxWindowDisabler,
37826 _swigc__p_wxXPMHandler,
37827 };
37828
37829
37830 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
37831
37832 static swig_const_info swig_const_table[] = {
37833 {0, 0, 0, 0.0, 0, 0}};
37834
37835 #ifdef __cplusplus
37836 }
37837 #endif
37838 /* -----------------------------------------------------------------------------
37839 * Type initialization:
37840 * This problem is tough by the requirement that no dynamic
37841 * memory is used. Also, since swig_type_info structures store pointers to
37842 * swig_cast_info structures and swig_cast_info structures store pointers back
37843 * to swig_type_info structures, we need some lookup code at initialization.
37844 * The idea is that swig generates all the structures that are needed.
37845 * The runtime then collects these partially filled structures.
37846 * The SWIG_InitializeModule function takes these initial arrays out of
37847 * swig_module, and does all the lookup, filling in the swig_module.types
37848 * array with the correct data and linking the correct swig_cast_info
37849 * structures together.
37850 *
37851 * The generated swig_type_info structures are assigned staticly to an initial
37852 * array. We just loop though that array, and handle each type individually.
37853 * First we lookup if this type has been already loaded, and if so, use the
37854 * loaded structure instead of the generated one. Then we have to fill in the
37855 * cast linked list. The cast data is initially stored in something like a
37856 * two-dimensional array. Each row corresponds to a type (there are the same
37857 * number of rows as there are in the swig_type_initial array). Each entry in
37858 * a column is one of the swig_cast_info structures for that type.
37859 * The cast_initial array is actually an array of arrays, because each row has
37860 * a variable number of columns. So to actually build the cast linked list,
37861 * we find the array of casts associated with the type, and loop through it
37862 * adding the casts to the list. The one last trick we need to do is making
37863 * sure the type pointer in the swig_cast_info struct is correct.
37864 *
37865 * First off, we lookup the cast->type name to see if it is already loaded.
37866 * There are three cases to handle:
37867 * 1) If the cast->type has already been loaded AND the type we are adding
37868 * casting info to has not been loaded (it is in this module), THEN we
37869 * replace the cast->type pointer with the type pointer that has already
37870 * been loaded.
37871 * 2) If BOTH types (the one we are adding casting info to, and the
37872 * cast->type) are loaded, THEN the cast info has already been loaded by
37873 * the previous module so we just ignore it.
37874 * 3) Finally, if cast->type has not already been loaded, then we add that
37875 * swig_cast_info to the linked list (because the cast->type) pointer will
37876 * be correct.
37877 * ----------------------------------------------------------------------------- */
37878
37879 #ifdef __cplusplus
37880 extern "C" {
37881 #if 0
37882 } /* c-mode */
37883 #endif
37884 #endif
37885
37886 #if 0
37887 #define SWIGRUNTIME_DEBUG
37888 #endif
37889
37890 SWIGRUNTIME void
37891 SWIG_InitializeModule(void *clientdata) {
37892 size_t i;
37893 swig_module_info *module_head;
37894 static int init_run = 0;
37895
37896 clientdata = clientdata;
37897
37898 if (init_run) return;
37899 init_run = 1;
37900
37901 /* Initialize the swig_module */
37902 swig_module.type_initial = swig_type_initial;
37903 swig_module.cast_initial = swig_cast_initial;
37904
37905 /* Try and load any already created modules */
37906 module_head = SWIG_GetModule(clientdata);
37907 if (module_head) {
37908 swig_module.next = module_head->next;
37909 module_head->next = &swig_module;
37910 } else {
37911 /* This is the first module loaded */
37912 swig_module.next = &swig_module;
37913 SWIG_SetModule(clientdata, &swig_module);
37914 }
37915
37916 /* Now work on filling in swig_module.types */
37917 #ifdef SWIGRUNTIME_DEBUG
37918 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
37919 #endif
37920 for (i = 0; i < swig_module.size; ++i) {
37921 swig_type_info *type = 0;
37922 swig_type_info *ret;
37923 swig_cast_info *cast;
37924
37925 #ifdef SWIGRUNTIME_DEBUG
37926 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
37927 #endif
37928
37929 /* if there is another module already loaded */
37930 if (swig_module.next != &swig_module) {
37931 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
37932 }
37933 if (type) {
37934 /* Overwrite clientdata field */
37935 #ifdef SWIGRUNTIME_DEBUG
37936 printf("SWIG_InitializeModule: found type %s\n", type->name);
37937 #endif
37938 if (swig_module.type_initial[i]->clientdata) {
37939 type->clientdata = swig_module.type_initial[i]->clientdata;
37940 #ifdef SWIGRUNTIME_DEBUG
37941 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
37942 #endif
37943 }
37944 } else {
37945 type = swig_module.type_initial[i];
37946 }
37947
37948 /* Insert casting types */
37949 cast = swig_module.cast_initial[i];
37950 while (cast->type) {
37951 /* Don't need to add information already in the list */
37952 ret = 0;
37953 #ifdef SWIGRUNTIME_DEBUG
37954 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
37955 #endif
37956 if (swig_module.next != &swig_module) {
37957 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
37958 #ifdef SWIGRUNTIME_DEBUG
37959 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
37960 #endif
37961 }
37962 if (ret) {
37963 if (type == swig_module.type_initial[i]) {
37964 #ifdef SWIGRUNTIME_DEBUG
37965 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
37966 #endif
37967 cast->type = ret;
37968 ret = 0;
37969 } else {
37970 /* Check for casting already in the list */
37971 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
37972 #ifdef SWIGRUNTIME_DEBUG
37973 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
37974 #endif
37975 if (!ocast) ret = 0;
37976 }
37977 }
37978
37979 if (!ret) {
37980 #ifdef SWIGRUNTIME_DEBUG
37981 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
37982 #endif
37983 if (type->cast) {
37984 type->cast->prev = cast;
37985 cast->next = type->cast;
37986 }
37987 type->cast = cast;
37988 }
37989 cast++;
37990 }
37991 /* Set entry in modules->types array equal to the type */
37992 swig_module.types[i] = type;
37993 }
37994 swig_module.types[i] = 0;
37995
37996 #ifdef SWIGRUNTIME_DEBUG
37997 printf("**** SWIG_InitializeModule: Cast List ******\n");
37998 for (i = 0; i < swig_module.size; ++i) {
37999 int j = 0;
38000 swig_cast_info *cast = swig_module.cast_initial[i];
38001 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38002 while (cast->type) {
38003 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38004 cast++;
38005 ++j;
38006 }
38007 printf("---- Total casts: %d\n",j);
38008 }
38009 printf("**** SWIG_InitializeModule: Cast List ******\n");
38010 #endif
38011 }
38012
38013 /* This function will propagate the clientdata field of type to
38014 * any new swig_type_info structures that have been added into the list
38015 * of equivalent types. It is like calling
38016 * SWIG_TypeClientData(type, clientdata) a second time.
38017 */
38018 SWIGRUNTIME void
38019 SWIG_PropagateClientData(void) {
38020 size_t i;
38021 swig_cast_info *equiv;
38022 static int init_run = 0;
38023
38024 if (init_run) return;
38025 init_run = 1;
38026
38027 for (i = 0; i < swig_module.size; i++) {
38028 if (swig_module.types[i]->clientdata) {
38029 equiv = swig_module.types[i]->cast;
38030 while (equiv) {
38031 if (!equiv->converter) {
38032 if (equiv->type && !equiv->type->clientdata)
38033 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38034 }
38035 equiv = equiv->next;
38036 }
38037 }
38038 }
38039 }
38040
38041 #ifdef __cplusplus
38042 #if 0
38043 {
38044 /* c-mode */
38045 #endif
38046 }
38047 #endif
38048
38049
38050
38051 #ifdef __cplusplus
38052 extern "C" {
38053 #endif
38054
38055 /* Python-specific SWIG API */
38056 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38057 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38058 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38059
38060 /* -----------------------------------------------------------------------------
38061 * global variable support code.
38062 * ----------------------------------------------------------------------------- */
38063
38064 typedef struct swig_globalvar {
38065 char *name; /* Name of global variable */
38066 PyObject *(*get_attr)(void); /* Return the current value */
38067 int (*set_attr)(PyObject *); /* Set the value */
38068 struct swig_globalvar *next;
38069 } swig_globalvar;
38070
38071 typedef struct swig_varlinkobject {
38072 PyObject_HEAD
38073 swig_globalvar *vars;
38074 } swig_varlinkobject;
38075
38076 SWIGINTERN PyObject *
38077 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38078 return PyString_FromString("<Swig global variables>");
38079 }
38080
38081 SWIGINTERN PyObject *
38082 swig_varlink_str(swig_varlinkobject *v) {
38083 PyObject *str = PyString_FromString("(");
38084 swig_globalvar *var;
38085 for (var = v->vars; var; var=var->next) {
38086 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38087 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38088 }
38089 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38090 return str;
38091 }
38092
38093 SWIGINTERN int
38094 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38095 PyObject *str = swig_varlink_str(v);
38096 fprintf(fp,"Swig global variables ");
38097 fprintf(fp,"%s\n", PyString_AsString(str));
38098 Py_DECREF(str);
38099 return 0;
38100 }
38101
38102 SWIGINTERN void
38103 swig_varlink_dealloc(swig_varlinkobject *v) {
38104 swig_globalvar *var = v->vars;
38105 while (var) {
38106 swig_globalvar *n = var->next;
38107 free(var->name);
38108 free(var);
38109 var = n;
38110 }
38111 }
38112
38113 SWIGINTERN PyObject *
38114 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38115 PyObject *res = NULL;
38116 swig_globalvar *var = v->vars;
38117 while (var) {
38118 if (strcmp(var->name,n) == 0) {
38119 res = (*var->get_attr)();
38120 break;
38121 }
38122 var = var->next;
38123 }
38124 if (res == NULL && !PyErr_Occurred()) {
38125 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38126 }
38127 return res;
38128 }
38129
38130 SWIGINTERN int
38131 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38132 int res = 1;
38133 swig_globalvar *var = v->vars;
38134 while (var) {
38135 if (strcmp(var->name,n) == 0) {
38136 res = (*var->set_attr)(p);
38137 break;
38138 }
38139 var = var->next;
38140 }
38141 if (res == 1 && !PyErr_Occurred()) {
38142 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38143 }
38144 return res;
38145 }
38146
38147 SWIGINTERN PyTypeObject*
38148 swig_varlink_type(void) {
38149 static char varlink__doc__[] = "Swig var link object";
38150 static PyTypeObject varlink_type;
38151 static int type_init = 0;
38152 if (!type_init) {
38153 const PyTypeObject tmp
38154 = {
38155 PyObject_HEAD_INIT(NULL)
38156 0, /* Number of items in variable part (ob_size) */
38157 (char *)"swigvarlink", /* Type name (tp_name) */
38158 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38159 0, /* Itemsize (tp_itemsize) */
38160 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38161 (printfunc) swig_varlink_print, /* Print (tp_print) */
38162 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38163 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38164 0, /* tp_compare */
38165 (reprfunc) swig_varlink_repr, /* tp_repr */
38166 0, /* tp_as_number */
38167 0, /* tp_as_sequence */
38168 0, /* tp_as_mapping */
38169 0, /* tp_hash */
38170 0, /* tp_call */
38171 (reprfunc)swig_varlink_str, /* tp_str */
38172 0, /* tp_getattro */
38173 0, /* tp_setattro */
38174 0, /* tp_as_buffer */
38175 0, /* tp_flags */
38176 varlink__doc__, /* tp_doc */
38177 0, /* tp_traverse */
38178 0, /* tp_clear */
38179 0, /* tp_richcompare */
38180 0, /* tp_weaklistoffset */
38181 #if PY_VERSION_HEX >= 0x02020000
38182 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38183 #endif
38184 #if PY_VERSION_HEX >= 0x02030000
38185 0, /* tp_del */
38186 #endif
38187 #ifdef COUNT_ALLOCS
38188 0,0,0,0 /* tp_alloc -> tp_next */
38189 #endif
38190 };
38191 varlink_type = tmp;
38192 varlink_type.ob_type = &PyType_Type;
38193 type_init = 1;
38194 }
38195 return &varlink_type;
38196 }
38197
38198 /* Create a variable linking object for use later */
38199 SWIGINTERN PyObject *
38200 SWIG_Python_newvarlink(void) {
38201 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38202 if (result) {
38203 result->vars = 0;
38204 }
38205 return ((PyObject*) result);
38206 }
38207
38208 SWIGINTERN void
38209 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38210 swig_varlinkobject *v = (swig_varlinkobject *) p;
38211 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38212 if (gv) {
38213 size_t size = strlen(name)+1;
38214 gv->name = (char *)malloc(size);
38215 if (gv->name) {
38216 strncpy(gv->name,name,size);
38217 gv->get_attr = get_attr;
38218 gv->set_attr = set_attr;
38219 gv->next = v->vars;
38220 }
38221 }
38222 v->vars = gv;
38223 }
38224
38225 SWIGINTERN PyObject *
38226 SWIG_globals() {
38227 static PyObject *_SWIG_globals = 0;
38228 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38229 return _SWIG_globals;
38230 }
38231
38232 /* -----------------------------------------------------------------------------
38233 * constants/methods manipulation
38234 * ----------------------------------------------------------------------------- */
38235
38236 /* Install Constants */
38237 SWIGINTERN void
38238 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38239 PyObject *obj = 0;
38240 size_t i;
38241 for (i = 0; constants[i].type; ++i) {
38242 switch(constants[i].type) {
38243 case SWIG_PY_POINTER:
38244 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38245 break;
38246 case SWIG_PY_BINARY:
38247 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38248 break;
38249 default:
38250 obj = 0;
38251 break;
38252 }
38253 if (obj) {
38254 PyDict_SetItemString(d, constants[i].name, obj);
38255 Py_DECREF(obj);
38256 }
38257 }
38258 }
38259
38260 /* -----------------------------------------------------------------------------*/
38261 /* Fix SwigMethods to carry the callback ptrs when needed */
38262 /* -----------------------------------------------------------------------------*/
38263
38264 SWIGINTERN void
38265 SWIG_Python_FixMethods(PyMethodDef *methods,
38266 swig_const_info *const_table,
38267 swig_type_info **types,
38268 swig_type_info **types_initial) {
38269 size_t i;
38270 for (i = 0; methods[i].ml_name; ++i) {
38271 char *c = methods[i].ml_doc;
38272 if (c && (c = strstr(c, "swig_ptr: "))) {
38273 int j;
38274 swig_const_info *ci = 0;
38275 char *name = c + 10;
38276 for (j = 0; const_table[j].type; ++j) {
38277 if (strncmp(const_table[j].name, name,
38278 strlen(const_table[j].name)) == 0) {
38279 ci = &(const_table[j]);
38280 break;
38281 }
38282 }
38283 if (ci) {
38284 size_t shift = (ci->ptype) - types;
38285 swig_type_info *ty = types_initial[shift];
38286 size_t ldoc = (c - methods[i].ml_doc);
38287 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38288 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38289 if (ndoc) {
38290 char *buff = ndoc;
38291 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38292 if (ptr) {
38293 strncpy(buff, methods[i].ml_doc, ldoc);
38294 buff += ldoc;
38295 strncpy(buff, "swig_ptr: ", 10);
38296 buff += 10;
38297 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38298 methods[i].ml_doc = ndoc;
38299 }
38300 }
38301 }
38302 }
38303 }
38304 }
38305
38306 #ifdef __cplusplus
38307 }
38308 #endif
38309
38310 /* -----------------------------------------------------------------------------*
38311 * Partial Init method
38312 * -----------------------------------------------------------------------------*/
38313
38314 #ifdef __cplusplus
38315 extern "C"
38316 #endif
38317 SWIGEXPORT void SWIG_init(void) {
38318 PyObject *m, *d;
38319
38320 /* Fix SwigMethods to carry the callback ptrs when needed */
38321 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38322
38323 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38324 d = PyModule_GetDict(m);
38325
38326 SWIG_InitializeModule(0);
38327 SWIG_InstallConstants(d,swig_const_table);
38328
38329
38330 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38331 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38332 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38333 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38334 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38335 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38336 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38337 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38338 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38339 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38340 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38341 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38342 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38343 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38344 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38345 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38346 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38347 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38348 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38349 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38350 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38351 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38352 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38353 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38354 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38355 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38356 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38357 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38358 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38359 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38360 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38361 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38362 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38363 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38364 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38365 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38366 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38367 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38368 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38369 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38370 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38371 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38372 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38373 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38374 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38375 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38376 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38377 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38378 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38379 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38380 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38381 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38382 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38383 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38384 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38385 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38386 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38387 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38388 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38389 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38390 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38391 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38392 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38393 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38394 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38395 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38396 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38397 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38398 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38399 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38400 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38401 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38402 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38403 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38404 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38405 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38406 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38407 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38408 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38409 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38410 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38411 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38412 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38413 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38414 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38415 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38416 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38417 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38418 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38419 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38420 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38421 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38422 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38423 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38424 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38425 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38426 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38427 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38428 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38429 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38430 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38431 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38432
38433 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38434
38435 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38436 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38437 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38438 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38439 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38440 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38441 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38442 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38443 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38444 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38445 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38446 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38447 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38448 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38449 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38450 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38451 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38452 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38453 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38454 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38455 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38456 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38457 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38458 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38459 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38460 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38461 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38462 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38463 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38464 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38465 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38466 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38467 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38468 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38469 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38470 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38471 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38472 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38473 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38474 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38475 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38476 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38477 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38478 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38479 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38480 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38481 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38482 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38483 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38484 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38485 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38486 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38487 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38488
38489 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38490
38491 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38492 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38493 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38494 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38495 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38496 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38497 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38498 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38499 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38500 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38501 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38502 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38503 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38504 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38505 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38506 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38507 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38508 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38509 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38510 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38511 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38512 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38513 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38514 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38515 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38516 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38517 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38518 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38519 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38520 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38521 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38522 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38523 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38524 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38525 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38526 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38527 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38528 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38529 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38530 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38531 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38532 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38533 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38534 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38535 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38536 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38537 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38538 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38539 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38540 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38541 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38542 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38543 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38544 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38545 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38546 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38547 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38548 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38549 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38550 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38551 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38552 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38553 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38554 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38555 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38556 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38557 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38558 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38559 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38560 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38561 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38562 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38563 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38564 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38565 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38566 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38567
38568 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38569
38570 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38571 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38572 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38573 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38574 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38575 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38576 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38577 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38578 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38579 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38580 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38581 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38582 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38583 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38584 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38585 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38586 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38587 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38588 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38589 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38590 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38591 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38592 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38593 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38594 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38595 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38596 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38597 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38598 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38599 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38600 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38601 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38602 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38603 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38604 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38605 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38606 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38607 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38608 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38609 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38610 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38611 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38612 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38613 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38614 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38615 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38616 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38617 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38618 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38619 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38620 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38621 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38622 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38623 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38624 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38625 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38626 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38627 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38628 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38629 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38630 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38631 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38632 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38633 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38634 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38635 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38636 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38637 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38638 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38639 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38640 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38641 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38642 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38643 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38644 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38645 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38646 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38647 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38648 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38649 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38650 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38651 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38652 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38653 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38654 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38655 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38656 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38657 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38658 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38659 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38660 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38661 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38662 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38663 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38664 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38665 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38666 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38667 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38668 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38669 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38670 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38671 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38672 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38673 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38674 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38675 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38676 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38677 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38678 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38679 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38680 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38681 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38682 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38683 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38684 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38685 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38686 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38687 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38688 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38689 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38690 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38691 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38692 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38693 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38694 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38695 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38696 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38697 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38698 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38699 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38700 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38701 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38702 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38703 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38704 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38705 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38706 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38707 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38708 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38709 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38710 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38711 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38712 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38713 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38714 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38715 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38716 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38717 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38718 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38719 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38720 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38721 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38722 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38723 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38724 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38725 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38726 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38727 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38728 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38729 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38730 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38731 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38732 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38733 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38734 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38735 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38736 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38737 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38738 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38739 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38740 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38741 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38742 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38743 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38744 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38745 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38746 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38747 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38748 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38749 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38750 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38751 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38752 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38753 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38754 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38755 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38756 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38757 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38758 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38759 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38760 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38761 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38762 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38763 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38764 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38765 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38766 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38767 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38768 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38769 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38770
38771 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38772 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38773 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
38774 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
38775
38776 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
38777 }
38778
wxWidgets (Impactor)