]> 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_wxClipboardTextEvent swig_types[23]
2486 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2487 #define SWIGTYPE_p_wxColour swig_types[25]
2488 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2489 #define SWIGTYPE_p_wxConfig swig_types[27]
2490 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2491 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2492 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2493 #define SWIGTYPE_p_wxControl swig_types[31]
2494 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2495 #define SWIGTYPE_p_wxCursor swig_types[33]
2496 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2497 #define SWIGTYPE_p_wxDC swig_types[35]
2498 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2499 #define SWIGTYPE_p_wxDataObject swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2501 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2502 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2503 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime swig_types[42]
2505 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2506 #define SWIGTYPE_p_wxDisplay swig_types[44]
2507 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2509 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2510 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvent swig_types[49]
2512 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2513 #define SWIGTYPE_p_wxFSFile swig_types[51]
2514 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2515 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2516 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2517 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2518 #define SWIGTYPE_p_wxFileType swig_types[56]
2519 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2520 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2521 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2522 #define SWIGTYPE_p_wxFont swig_types[60]
2523 #define SWIGTYPE_p_wxFrame swig_types[61]
2524 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2525 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2526 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2527 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2528 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2529 #define SWIGTYPE_p_wxIcon swig_types[67]
2530 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2532 #define SWIGTYPE_p_wxImage swig_types[70]
2533 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2534 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2535 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2536 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2537 #define SWIGTYPE_p_wxJoystick swig_types[75]
2538 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2540 #define SWIGTYPE_p_wxKillError swig_types[78]
2541 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2542 #define SWIGTYPE_p_wxLog swig_types[80]
2543 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2544 #define SWIGTYPE_p_wxLogChain swig_types[82]
2545 #define SWIGTYPE_p_wxLogGui swig_types[83]
2546 #define SWIGTYPE_p_wxLogNull swig_types[84]
2547 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2548 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2549 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2550 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2551 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2552 #define SWIGTYPE_p_wxMenu swig_types[90]
2553 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2554 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2576 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2577 #define SWIGTYPE_p_wxPyApp swig_types[115]
2578 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2579 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2580 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2581 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2583 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2585 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2586 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2587 #define SWIGTYPE_p_wxPyLog swig_types[125]
2588 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2589 #define SWIGTYPE_p_wxPySizer swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2591 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2592 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2593 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2594 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2595 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2596 #define SWIGTYPE_p_wxRect swig_types[134]
2597 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2598 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2600 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2601 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2602 #define SWIGTYPE_p_wxSize swig_types[140]
2603 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2604 #define SWIGTYPE_p_wxSizer swig_types[142]
2605 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2606 #define SWIGTYPE_p_wxSound swig_types[144]
2607 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2608 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2610 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2611 #define SWIGTYPE_p_wxString swig_types[149]
2612 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2613 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2614 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2615 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2616 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2617 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2618 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2619 #define SWIGTYPE_p_wxTimer swig_types[157]
2620 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2621 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2622 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2623 #define SWIGTYPE_p_wxToolTip swig_types[161]
2624 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2625 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2626 #define SWIGTYPE_p_wxValidator swig_types[164]
2627 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2628 #define SWIGTYPE_p_wxWindow swig_types[166]
2629 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2631 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2632 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2633 static swig_type_info *swig_types[172];
2634 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2635 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2636 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2637
2638 /* -------- TYPES TABLE (END) -------- */
2639
2640 #if (PY_VERSION_HEX <= 0x02000000)
2641 # if !defined(SWIG_PYTHON_CLASSIC)
2642 # error "This python version requires to use swig with the '-classic' option"
2643 # endif
2644 #endif
2645 #if (PY_VERSION_HEX <= 0x02020000)
2646 # error "This python version requires to use swig with the '-nomodern' option"
2647 #endif
2648 #if (PY_VERSION_HEX <= 0x02020000)
2649 # error "This python version requires to use swig with the '-nomodernargs' option"
2650 #endif
2651 #ifndef METH_O
2652 # error "This python version requires to use swig with the '-nofastunpack' option"
2653 #endif
2654
2655 /*-----------------------------------------------
2656 @(target):= _misc_.so
2657 ------------------------------------------------*/
2658 #define SWIG_init init_misc_
2659
2660 #define SWIG_name "_misc_"
2661
2662 #define SWIGVERSION 0x010329
2663
2664
2665 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2666 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2667
2668
2669 #include <stdexcept>
2670
2671
2672 namespace swig {
2673 class PyObject_ptr {
2674 protected:
2675 PyObject *_obj;
2676
2677 public:
2678 PyObject_ptr() :_obj(0)
2679 {
2680 }
2681
2682 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2683 {
2684 Py_XINCREF(_obj);
2685 }
2686
2687 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2688 {
2689 if (initial_ref) Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr & operator=(const PyObject_ptr& item)
2693 {
2694 Py_XINCREF(item._obj);
2695 Py_XDECREF(_obj);
2696 _obj = item._obj;
2697 return *this;
2698 }
2699
2700 ~PyObject_ptr()
2701 {
2702 Py_XDECREF(_obj);
2703 }
2704
2705 operator PyObject *() const
2706 {
2707 return _obj;
2708 }
2709
2710 PyObject *operator->() const
2711 {
2712 return _obj;
2713 }
2714 };
2715 }
2716
2717
2718 namespace swig {
2719 struct PyObject_var : PyObject_ptr {
2720 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2721
2722 PyObject_var & operator = (PyObject* obj)
2723 {
2724 Py_XDECREF(_obj);
2725 _obj = obj;
2726 return *this;
2727 }
2728 };
2729 }
2730
2731
2732 #include "wx/wxPython/wxPython.h"
2733 #include "wx/wxPython/pyclasses.h"
2734 #include "wx/wxPython/pyistream.h"
2735
2736 static const wxString wxPyEmptyString(wxEmptyString);
2737
2738
2739
2740 #define SWIG_From_long PyInt_FromLong
2741
2742
2743 SWIGINTERNINLINE PyObject *
2744 SWIG_From_int (int value)
2745 {
2746 return SWIG_From_long (value);
2747 }
2748
2749
2750 #include <limits.h>
2751 #ifndef LLONG_MIN
2752 # define LLONG_MIN LONG_LONG_MIN
2753 #endif
2754 #ifndef LLONG_MAX
2755 # define LLONG_MAX LONG_LONG_MAX
2756 #endif
2757 #ifndef ULLONG_MAX
2758 # define ULLONG_MAX ULONG_LONG_MAX
2759 #endif
2760
2761
2762 SWIGINTERN int
2763 SWIG_AsVal_long (PyObject* obj, long* val)
2764 {
2765 if (PyNumber_Check(obj)) {
2766 if (val) *val = PyInt_AsLong(obj);
2767 return SWIG_OK;
2768 }
2769 return SWIG_TypeError;
2770 }
2771
2772
2773 SWIGINTERN int
2774 SWIG_AsVal_int (PyObject * obj, int *val)
2775 {
2776 long v;
2777 int res = SWIG_AsVal_long (obj, &v);
2778 if (SWIG_IsOK(res)) {
2779 if ((v < INT_MIN || v > INT_MAX)) {
2780 return SWIG_OverflowError;
2781 } else {
2782 if (val) *val = static_cast< int >(v);
2783 }
2784 }
2785 return res;
2786 }
2787
2788 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2789
2790 #include <wx/stockitem.h>
2791
2792 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2793 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2794 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2795
2796 SWIGINTERN int
2797 SWIG_AsVal_bool (PyObject *obj, bool *val)
2798 {
2799 if (obj == Py_True) {
2800 if (val) *val = true;
2801 return SWIG_OK;
2802 } else if (obj == Py_False) {
2803 if (val) *val = false;
2804 return SWIG_OK;
2805 } else {
2806 long v = 0;
2807 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2808 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2809 return res;
2810 }
2811 }
2812
2813
2814 wxMemorySize wxGetFreeMemory()
2815 { wxPyRaiseNotImplemented(); return 0; }
2816
2817
2818 SWIGINTERN int
2819 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2820 {
2821 long v = 0;
2822 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2823 return SWIG_TypeError;
2824 }
2825 else if (val)
2826 *val = (unsigned long)v;
2827 return SWIG_OK;
2828 }
2829
2830
2831 SWIGINTERNINLINE PyObject*
2832 SWIG_From_unsigned_SS_long (unsigned long value)
2833 {
2834 return (value > LONG_MAX) ?
2835 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2836 }
2837
2838
2839 void* wxGetXDisplay()
2840 {
2841 #ifdef __WXGTK__
2842 return wxGetDisplay();
2843 #else
2844 return NULL;
2845 #endif
2846 }
2847
2848
2849 wxWindow* FindWindowAtPointer() {
2850 wxPoint unused;
2851 return wxFindWindowAtPointer(unused);
2852 }
2853
2854
2855 void wxWakeUpMainThread() {}
2856
2857
2858 bool wxThread_IsMain() {
2859 #ifdef WXP_WITH_THREAD
2860 return wxThread::IsMain();
2861 #else
2862 return true;
2863 #endif
2864 }
2865
2866 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2867 delete self;
2868 }
2869
2870 #include <wx/snglinst.h>
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h>
2875 #include <wx/dynload.h>
2876 #endif
2877
2878
2879
2880 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2881 #if 0
2882 , int method
2883 #endif
2884 )
2885 {
2886 #ifdef __WXMSW__
2887 #if 0
2888 switch (method)
2889 {
2890 case 1:
2891 // This one only partially works. Appears to be an undocumented
2892 // "standard" convention that not all widgets adhear to. For
2893 // example, for some widgets backgrounds or non-client areas may
2894 // not be painted.
2895 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2896 break;
2897
2898 case 2:
2899 #endif
2900 // This one works much better, nearly all widgets and their
2901 // children are captured correctly[**]. Prior to the big
2902 // background erase changes that Vadim did in 2004-2005 this
2903 // method failed badly on XP with Themes activated, most native
2904 // widgets draw only partially, if at all. Without themes it
2905 // worked just like on Win2k. After those changes this method
2906 // works very well.
2907 //
2908 // ** For example the radio buttons in a wxRadioBox are not its
2909 // children by default, but you can capture it via the panel
2910 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2911 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2912 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2913 PRF_ERASEBKGND | PRF_OWNED );
2914 return true;
2915 #if 0
2916 break;
2917
2918 case 3:
2919 // This one is only defined in the latest SDK and is only
2920 // available on XP. MSDN says it is similar to sending WM_PRINT
2921 // so I expect that it will work similar to the above. Since it
2922 // is avaialble only on XP, it can't be compiled like this and
2923 // will have to be loaded dynamically.
2924 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2925
2926 // fall through
2927
2928 case 4:
2929 // Use PrintWindow if available, or fallback to WM_PRINT
2930 // otherwise. Unfortunately using PrintWindow is even worse than
2931 // WM_PRINT. For most native widgets nothing is drawn to the dc
2932 // at all, with or without Themes.
2933 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2934 static bool s_triedToLoad = false;
2935 static PrintWindow_t pfnPrintWindow = NULL;
2936 if ( !s_triedToLoad )
2937 {
2938
2939 s_triedToLoad = true;
2940 wxDynamicLibrary dllUser32(_T("user32.dll"));
2941 if ( dllUser32.IsLoaded() )
2942 {
2943 wxLogNull nolog; // Don't report errors here
2944 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2945 }
2946 }
2947 if (pfnPrintWindow)
2948 {
2949 //printf("Using PrintWindow\n");
2950 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2951 }
2952 else
2953 {
2954 //printf("Using WM_PRINT\n");
2955 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2956 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2957 PRF_ERASEBKGND | PRF_OWNED );
2958 }
2959 }
2960 #endif // 0
2961 #else
2962 return false;
2963 #endif // __WXMSW__
2964 }
2965
2966
2967
2968 #include <wx/tipdlg.h>
2969
2970
2971 SWIGINTERNINLINE PyObject *
2972 SWIG_From_size_t (size_t value)
2973 {
2974 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2975 }
2976
2977
2978 class wxPyTipProvider : public wxTipProvider {
2979 public:
2980 wxPyTipProvider(size_t currentTip)
2981 : wxTipProvider(currentTip) {}
2982
2983 DEC_PYCALLBACK_STRING__pure(GetTip);
2984 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2985 PYPRIVATE;
2986 };
2987
2988 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2989 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2990
2991
2992 SWIGINTERNINLINE int
2993 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2994 {
2995 unsigned long v;
2996 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2997 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2998 return res;
2999 }
3000
3001
3002 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3003
3004 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3005
3006 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3007 : wxTimer(owner, id)
3008 {
3009 if (owner == NULL)
3010 SetOwner(this);
3011 }
3012
3013
3014 SWIGINTERN swig_type_info*
3015 SWIG_pchar_descriptor()
3016 {
3017 static int init = 0;
3018 static swig_type_info* info = 0;
3019 if (!init) {
3020 info = SWIG_TypeQuery("_p_char");
3021 init = 1;
3022 }
3023 return info;
3024 }
3025
3026
3027 SWIGINTERNINLINE PyObject *
3028 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3029 {
3030 if (carray) {
3031 if (size > INT_MAX) {
3032 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3033 return pchar_descriptor ?
3034 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3035 } else {
3036 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3037 }
3038 } else {
3039 return SWIG_Py_Void();
3040 }
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtr(const char *cptr)
3046 {
3047 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3048 }
3049
3050
3051 SWIGINTERN int
3052 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3053 {
3054 unsigned long v;
3055 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3056 if (SWIG_IsOK(res)) {
3057 if ((v > UINT_MAX)) {
3058 return SWIG_OverflowError;
3059 } else {
3060 if (val) *val = static_cast< unsigned int >(v);
3061 }
3062 }
3063 return res;
3064 }
3065
3066 SWIGINTERN wxString wxLog_TimeStamp(){
3067 wxString msg;
3068 wxLog::TimeStamp(&msg);
3069 return msg;
3070 }
3071 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3072 // Make some wrappers that double any % signs so they are 'escaped'
3073 void wxPyLogFatalError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogFatalError(m);
3078 }
3079
3080 void wxPyLogError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogError(m);
3085 }
3086
3087 void wxPyLogWarning(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogWarning(m);
3092 }
3093
3094 void wxPyLogMessage(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogMessage(m);
3099 }
3100
3101 void wxPyLogInfo(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogInfo(m);
3106 }
3107
3108 void wxPyLogDebug(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogDebug(m);
3113 }
3114
3115 void wxPyLogVerbose(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogVerbose(m);
3120 }
3121
3122 void wxPyLogStatus(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(m);
3127 }
3128
3129 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(pFrame, m);
3134 }
3135
3136 void wxPyLogSysError(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogSysError(m);
3141 }
3142
3143 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogGeneric(level, m);
3148 }
3149
3150 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164
3165
3166 // A wxLog class that can be derived from in wxPython
3167 class wxPyLog : public wxLog {
3168 public:
3169 wxPyLog() : wxLog() {}
3170
3171 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3172 bool found;
3173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3174 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3175 PyObject* s = wx2PyString(szString);
3176 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3177 Py_DECREF(s);
3178 }
3179 wxPyEndBlockThreads(blocked);
3180 if (! found)
3181 wxLog::DoLog(level, szString, t);
3182 }
3183
3184 virtual void DoLogString(const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLogString(szString, t);
3195 }
3196
3197 DEC_PYCALLBACK_VOID_(Flush);
3198 PYPRIVATE;
3199 };
3200 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3201
3202
3203
3204
3205 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3206
3207
3208 #include <wx/joystick.h>
3209
3210
3211 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3212 // A C++ stub class for wxJoystick for platforms that don't have it.
3213 class wxJoystick : public wxObject {
3214 public:
3215 wxJoystick(int joystick = wxJOYSTICK1) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyErr_SetString(PyExc_NotImplementedError,
3218 "wxJoystick is not available on this platform.");
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 wxPoint GetPosition() { return wxPoint(-1,-1); }
3222 int GetZPosition() { return -1; }
3223 int GetButtonState() { return -1; }
3224 int GetPOVPosition() { return -1; }
3225 int GetPOVCTSPosition() { return -1; }
3226 int GetRudderPosition() { return -1; }
3227 int GetUPosition() { return -1; }
3228 int GetVPosition() { return -1; }
3229 int GetMovementThreshold() { return -1; }
3230 void SetMovementThreshold(int threshold) {}
3231
3232 bool IsOk(void) { return false; }
3233 int GetNumberJoysticks() { return -1; }
3234 int GetManufacturerId() { return -1; }
3235 int GetProductId() { return -1; }
3236 wxString GetProductName() { return wxEmptyString; }
3237 int GetXMin() { return -1; }
3238 int GetYMin() { return -1; }
3239 int GetZMin() { return -1; }
3240 int GetXMax() { return -1; }
3241 int GetYMax() { return -1; }
3242 int GetZMax() { return -1; }
3243 int GetNumberButtons() { return -1; }
3244 int GetNumberAxes() { return -1; }
3245 int GetMaxButtons() { return -1; }
3246 int GetMaxAxes() { return -1; }
3247 int GetPollingMin() { return -1; }
3248 int GetPollingMax() { return -1; }
3249 int GetRudderMin() { return -1; }
3250 int GetRudderMax() { return -1; }
3251 int GetUMin() { return -1; }
3252 int GetUMax() { return -1; }
3253 int GetVMin() { return -1; }
3254 int GetVMax() { return -1; }
3255
3256 bool HasRudder() { return false; }
3257 bool HasZ() { return false; }
3258 bool HasU() { return false; }
3259 bool HasV() { return false; }
3260 bool HasPOV() { return false; }
3261 bool HasPOV4Dir() { return false; }
3262 bool HasPOVCTS() { return false; }
3263
3264 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3265 bool ReleaseCapture() { return false; }
3266 };
3267 #endif
3268
3269
3270 #include <wx/sound.h>
3271
3272
3273 #if !wxUSE_SOUND
3274 // A C++ stub class for wxWave for platforms that don't have it.
3275 class wxSound : public wxObject
3276 {
3277 public:
3278 wxSound() {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(const wxString&/*, bool*/) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(int, const wxByte*) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 ~wxSound() {};
3298
3299 bool Create(const wxString&/*, bool*/) { return false; }
3300 bool Create(int, const wxByte*) { return false; };
3301 bool IsOk() { return false; };
3302 bool Play(unsigned) const { return false; }
3303 static bool Play(const wxString&, unsigned) { return false; }
3304 static void Stop() {}
3305 };
3306
3307 #endif
3308
3309 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3310 if (fileName.Length() == 0)
3311 return new wxSound;
3312 else
3313 return new wxSound(fileName);
3314 }
3315 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3316 unsigned char* buffer; int size;
3317 wxSound *sound = NULL;
3318
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 if (!PyArg_Parse(data, "t#", &buffer, &size))
3321 goto done;
3322 sound = new wxSound(size, buffer);
3323 done:
3324 wxPyEndBlockThreads(blocked);
3325 return sound;
3326 }
3327 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3328 #ifndef __WXMAC__
3329 unsigned char* buffer;
3330 int size;
3331 bool rv = false;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 rv = self->Create(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return rv;
3340 #else
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 PyErr_SetString(PyExc_NotImplementedError,
3343 "Create from data is not available on this platform.");
3344 wxPyEndBlockThreads(blocked);
3345 return false;
3346 #endif
3347 }
3348
3349 #include <wx/mimetype.h>
3350
3351 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3352 wxString str;
3353 if (self->GetMimeType(&str))
3354 return wx2PyString(str);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetMimeTypes(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetExtensions(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc))
3375 return new wxIcon(loc);
3376 else
3377 return NULL;
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc)) {
3382 wxString iconFile = loc.GetFileName();
3383 int iconIndex = -1;
3384
3385
3386
3387 // Make a tuple and put the values in it
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 PyObject* tuple = PyTuple_New(3);
3390 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3391 wxT("wxIcon"), true));
3392 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3393 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3394 wxPyEndBlockThreads(blocked);
3395 return tuple;
3396 }
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3401 wxString str;
3402 if (self->GetDescription(&str))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxArrayString verbs;
3423 wxArrayString commands;
3424 if (self->GetAllCommands(&verbs, &commands,
3425 wxFileType::MessageParameters(filename, mimetype))) {
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 PyObject* tuple = PyTuple_New(2);
3428 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3429 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3430 wxPyEndBlockThreads(blocked);
3431 return tuple;
3432 }
3433 else
3434 RETURN_NONE();
3435 }
3436 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3437 return wxFileType::ExpandCommand(command,
3438 wxFileType::MessageParameters(filename, mimetype));
3439 }
3440 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3441 wxArrayString arr;
3442 self->EnumAllFileTypes(arr);
3443 return wxArrayString2PyList_helper(arr);
3444 }
3445
3446 #include <wx/artprov.h>
3447
3448 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3449 static const wxString wxPyART_MENU(wxART_MENU);
3450 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3451 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3452 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3453 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3454 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3455 static const wxString wxPyART_OTHER(wxART_OTHER);
3456 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3457 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3458 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3459 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3460 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3461 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3462 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3463 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3464 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3465 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3466 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3467 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3468 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3469 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3470 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3471 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3472 static const wxString wxPyART_PRINT(wxART_PRINT);
3473 static const wxString wxPyART_HELP(wxART_HELP);
3474 static const wxString wxPyART_TIP(wxART_TIP);
3475 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3476 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3477 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3478 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3479 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3480 static const wxString wxPyART_CDROM(wxART_CDROM);
3481 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3482 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3483 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3484 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3485 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3486 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3487 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3488 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3489 static const wxString wxPyART_ERROR(wxART_ERROR);
3490 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3491 static const wxString wxPyART_WARNING(wxART_WARNING);
3492 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3493 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3494 static const wxString wxPyART_COPY(wxART_COPY);
3495 static const wxString wxPyART_CUT(wxART_CUT);
3496 static const wxString wxPyART_PASTE(wxART_PASTE);
3497 static const wxString wxPyART_DELETE(wxART_DELETE);
3498 static const wxString wxPyART_NEW(wxART_NEW);
3499 static const wxString wxPyART_UNDO(wxART_UNDO);
3500 static const wxString wxPyART_REDO(wxART_REDO);
3501 static const wxString wxPyART_QUIT(wxART_QUIT);
3502 static const wxString wxPyART_FIND(wxART_FIND);
3503 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3504 // Python aware wxArtProvider
3505 class wxPyArtProvider : public wxArtProvider {
3506 public:
3507
3508 virtual wxBitmap CreateBitmap(const wxArtID& id,
3509 const wxArtClient& client,
3510 const wxSize& size) {
3511 wxBitmap rval = wxNullBitmap;
3512 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3513 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3514 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3515 PyObject* ro;
3516 wxBitmap* ptr;
3517 PyObject* s1, *s2;
3518 s1 = wx2PyString(id);
3519 s2 = wx2PyString(client);
3520 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3521 Py_DECREF(so);
3522 Py_DECREF(s1);
3523 Py_DECREF(s2);
3524 if (ro) {
3525 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3526 rval = *ptr;
3527 Py_DECREF(ro);
3528 }
3529 }
3530 wxPyEndBlockThreads(blocked);
3531 return rval;
3532 }
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3538
3539
3540
3541 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3543 PyObject* ret = PyTuple_New(3);
3544 if (ret) {
3545 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3546 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3547 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3548 }
3549 wxPyEndBlockThreads(blocked);
3550 return ret;
3551 }
3552
3553 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3554 bool cont;
3555 long index = 0;
3556 wxString value;
3557
3558 cont = self->GetFirstGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3562 bool cont;
3563 wxString value;
3564
3565 cont = self->GetNextGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3569 bool cont;
3570 long index = 0;
3571 wxString value;
3572
3573 cont = self->GetFirstEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3577 bool cont;
3578 wxString value;
3579
3580 cont = self->GetNextEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3584 long rv;
3585 self->Read(key, &rv, defaultVal);
3586 return rv;
3587 }
3588
3589 SWIGINTERN int
3590 SWIG_AsVal_double (PyObject *obj, double* val)
3591 {
3592 if (PyNumber_Check(obj)) {
3593 if (val) *val = PyFloat_AsDouble(obj);
3594 return SWIG_OK;
3595 }
3596 return SWIG_TypeError;
3597 }
3598
3599 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3600 double rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #define SWIG_From_double PyFloat_FromDouble
3606
3607 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3608 bool rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #include <wx/datetime.h>
3614
3615 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3616 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3617
3618 #define LOCAL_TZ wxDateTime::Local
3619
3620 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3621 wxString am;
3622 wxString pm;
3623 wxDateTime::GetAmPmStrings(&am, &pm);
3624 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3625 PyObject* tup = PyTuple_New(2);
3626 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3627 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3628 wxPyEndBlockThreads(blocked);
3629 return tup;
3630 }
3631
3632 SWIGINTERNINLINE PyObject *
3633 SWIG_From_unsigned_SS_int (unsigned int value)
3634 {
3635 return SWIG_From_unsigned_SS_long (value);
3636 }
3637
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3640 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3643 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3645 return (*self < *other);
3646 }
3647 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3649 return (*self <= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3653 return (*self > *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3657 return (*self >= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3661 return (*self == *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3665 return (*self != *other);
3666 }
3667 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseRfc822Date(_date);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseFormat(_date, format, dateDef);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3682 const wxChar* rv;
3683 const wxChar* _datetime = datetime;
3684 rv = self->ParseDateTime(_datetime);
3685 if (rv == NULL) return -1;
3686 return rv - _datetime;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseDate(_date);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3696 const wxChar* rv;
3697 const wxChar* _time = time;
3698 rv = self->ParseTime(_time);
3699 if (rv == NULL) return -1;
3700 return rv - _time;
3701 }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3712 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3715 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3716 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3718
3719 #include <wx/dataobj.h>
3720
3721 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3722 size_t count = self->GetFormatCount(dir);
3723 wxDataFormat* formats = new wxDataFormat[count];
3724 self->GetAllFormats(formats, dir);
3725
3726 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3727 PyObject* list = PyList_New(count);
3728 for (size_t i=0; i<count; i++) {
3729 wxDataFormat* format = new wxDataFormat(formats[i]);
3730 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3731 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 delete [] formats;
3735 return list;
3736 }
3737 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3738 PyObject* rval = NULL;
3739 size_t size = self->GetDataSize(format);
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 if (size) {
3742 char* buf = new char[size];
3743 if (self->GetDataHere(format, buf))
3744 rval = PyString_FromStringAndSize(buf, size);
3745 delete [] buf;
3746 }
3747 if (! rval) {
3748 rval = Py_None;
3749 Py_INCREF(rval);
3750 }
3751 wxPyEndBlockThreads(blocked);
3752 return rval;
3753 }
3754 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3755 bool rval;
3756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3757 if (PyString_Check(data)) {
3758 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3759 }
3760 else {
3761 // raise a TypeError if not a string
3762 PyErr_SetString(PyExc_TypeError, "String expected.");
3763 rval = false;
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3769 PyObject* rval = NULL;
3770 size_t size = self->GetDataSize();
3771 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3772 if (size) {
3773 char* buf = new char[size];
3774 if (self->GetDataHere(buf))
3775 rval = PyString_FromStringAndSize(buf, size);
3776 delete [] buf;
3777 }
3778 if (! rval) {
3779 rval = Py_None;
3780 Py_INCREF(rval);
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return rval;
3784 }
3785 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3786 bool rval;
3787 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3788 if (PyString_Check(data)) {
3789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3790 }
3791 else {
3792 // raise a TypeError if not a string
3793 PyErr_SetString(PyExc_TypeError, "String expected.");
3794 rval = false;
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 // Create a new class for wxPython to use
3800 class wxPyDataObjectSimple : public wxDataObjectSimple {
3801 public:
3802 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3803 : wxDataObjectSimple(format) {}
3804
3805 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3806 bool GetDataHere(void *buf) const;
3807 bool SetData(size_t len, const void *buf) const;
3808 PYPRIVATE;
3809 };
3810
3811 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3812
3813 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3814 // We need to get the data for this object and write it to buf. I think
3815 // the best way to do this for wxPython is to have the Python method
3816 // return either a string or None and then act appropriately with the
3817 // C++ version.
3818
3819 bool rval = false;
3820 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3821 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3822 PyObject* ro;
3823 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3824 if (ro) {
3825 rval = (ro != Py_None && PyString_Check(ro));
3826 if (rval)
3827 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3828 Py_DECREF(ro);
3829 }
3830 }
3831 wxPyEndBlockThreads(blocked);
3832 return rval;
3833 }
3834
3835 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3836 // For this one we simply need to make a string from buf and len
3837 // and send it to the Python method.
3838 bool rval = false;
3839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3840 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3841 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3842 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3843 Py_DECREF(data);
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 // Create a new class for wxPython to use
3850 class wxPyTextDataObject : public wxTextDataObject {
3851 public:
3852 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3853 : wxTextDataObject(text) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3856 DEC_PYCALLBACK_STRING__const(GetText);
3857 DEC_PYCALLBACK__STRING(SetText);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3862 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3863 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3864
3865
3866 // Create a new class for wxPython to use
3867 class wxPyBitmapDataObject : public wxBitmapDataObject {
3868 public:
3869 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3870 : wxBitmapDataObject(bitmap) {}
3871
3872 wxBitmap GetBitmap() const;
3873 void SetBitmap(const wxBitmap& bitmap);
3874 PYPRIVATE;
3875 };
3876
3877 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3878 wxBitmap* rval = &wxNullBitmap;
3879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3880 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3881 PyObject* ro;
3882 wxBitmap* ptr;
3883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3884 if (ro) {
3885 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3886 rval = ptr;
3887 Py_DECREF(ro);
3888 }
3889 }
3890 wxPyEndBlockThreads(blocked);
3891 return *rval;
3892 }
3893
3894 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3896 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3897 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3898 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3899 Py_DECREF(bo);
3900 }
3901 wxPyEndBlockThreads(blocked);
3902 }
3903
3904 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3905 return new wxCustomDataObject(wxDataFormat(formatName));
3906 }
3907 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3908 bool rval;
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (PyString_Check(data)) {
3911 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3912 }
3913 else {
3914 // raise a TypeError if not a string
3915 PyErr_SetString(PyExc_TypeError, "String expected.");
3916 rval = false;
3917 }
3918 wxPyEndBlockThreads(blocked);
3919 return rval;
3920 }
3921 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3922 PyObject* obj;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3925 wxPyEndBlockThreads(blocked);
3926 return obj;
3927 }
3928
3929 class wxMetafileDataObject : public wxDataObjectSimple
3930 {
3931 public:
3932 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3933 };
3934
3935
3936 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3937
3938
3939 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3940 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3941 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3942 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3943 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3944
3945
3946 class wxPyTextDropTarget : public wxTextDropTarget {
3947 public:
3948 wxPyTextDropTarget() {}
3949
3950 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3951
3952 DEC_PYCALLBACK__(OnLeave);
3953 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3954 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3955 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3956 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3957
3958 PYPRIVATE;
3959 };
3960
3961 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3962 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3963 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3964 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3965 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3966 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3967
3968
3969
3970 class wxPyFileDropTarget : public wxFileDropTarget {
3971 public:
3972 wxPyFileDropTarget() {}
3973
3974 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3975
3976 DEC_PYCALLBACK__(OnLeave);
3977 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3978 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3979 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3980 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3981
3982 PYPRIVATE;
3983 };
3984
3985 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3986 const wxArrayString& filenames) {
3987 bool rval = false;
3988 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3989 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3990 PyObject* list = wxArrayString2PyList_helper(filenames);
3991 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3992 Py_DECREF(list);
3993 }
3994 wxPyEndBlockThreads(blocked);
3995 return rval;
3996 }
3997
3998
3999
4000 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4001 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4002 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4003 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4004 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4005
4006
4007
4008
4009 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4010
4011 #include <wx/display.h>
4012
4013 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4014 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4015
4016 #if !wxUSE_DISPLAY
4017 const wxVideoMode wxDefaultVideoMode;
4018 #endif
4019
4020 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4021 #if wxUSE_DISPLAY
4022 PyObject* pyList = NULL;
4023 wxArrayVideoModes arr = self->GetModes(mode);
4024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4025 pyList = PyList_New(0);
4026 for (size_t i=0; i < arr.GetCount(); i++)
4027 {
4028 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4029 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4030 PyList_Append(pyList, pyObj);
4031 Py_DECREF(pyObj);
4032 }
4033 wxPyEndBlockThreads(blocked);
4034 return pyList;
4035 #else
4036 wxPyRaiseNotImplemented();
4037 return NULL;
4038 #endif
4039 }
4040 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4041 #if wxUSE_DISPLAY
4042 return self->GetCurrentMode();
4043 #else
4044 wxPyRaiseNotImplemented();
4045 return wxDefaultVideoMode;
4046 #endif
4047 }
4048 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4049 #if wxUSE_DISPLAY
4050 return self->ChangeMode(mode);
4051 #else
4052 wxPyRaiseNotImplemented();
4053 return false;
4054 #endif
4055 }
4056 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4057 #if wxUSE_DISPLAY
4058 self->ResetMode();
4059 #else
4060 wxPyRaiseNotImplemented();
4061 #endif
4062 }
4063
4064 #include <wx/stdpaths.h>
4065
4066 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4067 return (wxStandardPaths*) &wxStandardPaths::Get();
4068 }
4069
4070 #ifndef wxHAS_POWER_EVENTS
4071 // Dummy class and other definitions for platforms that don't have them
4072
4073 // See wxPython_int.h for wxPowerEvent
4074
4075 enum {
4076 wxEVT_POWER_SUSPENDING,
4077 wxEVT_POWER_SUSPENDED,
4078 wxEVT_POWER_SUSPEND_CANCEL,
4079 wxEVT_POWER_RESUME,
4080 };
4081
4082 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4083 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4084
4085 #endif
4086
4087 #ifdef __cplusplus
4088 extern "C" {
4089 #endif
4090 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4091 PyObject *resultobj = 0;
4092 wxSystemColour arg1 ;
4093 wxColour result;
4094 int val1 ;
4095 int ecode1 = 0 ;
4096 PyObject * obj0 = 0 ;
4097 char * kwnames[] = {
4098 (char *) "index", NULL
4099 };
4100
4101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4102 ecode1 = SWIG_AsVal_int(obj0, &val1);
4103 if (!SWIG_IsOK(ecode1)) {
4104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4105 }
4106 arg1 = static_cast< wxSystemColour >(val1);
4107 {
4108 if (!wxPyCheckForApp()) SWIG_fail;
4109 PyThreadState* __tstate = wxPyBeginAllowThreads();
4110 result = wxSystemSettings::GetColour(arg1);
4111 wxPyEndAllowThreads(__tstate);
4112 if (PyErr_Occurred()) SWIG_fail;
4113 }
4114 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4115 return resultobj;
4116 fail:
4117 return NULL;
4118 }
4119
4120
4121 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4122 PyObject *resultobj = 0;
4123 wxSystemFont arg1 ;
4124 wxFont result;
4125 int val1 ;
4126 int ecode1 = 0 ;
4127 PyObject * obj0 = 0 ;
4128 char * kwnames[] = {
4129 (char *) "index", NULL
4130 };
4131
4132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4133 ecode1 = SWIG_AsVal_int(obj0, &val1);
4134 if (!SWIG_IsOK(ecode1)) {
4135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4136 }
4137 arg1 = static_cast< wxSystemFont >(val1);
4138 {
4139 if (!wxPyCheckForApp()) SWIG_fail;
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 result = wxSystemSettings::GetFont(arg1);
4142 wxPyEndAllowThreads(__tstate);
4143 if (PyErr_Occurred()) SWIG_fail;
4144 }
4145 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4146 return resultobj;
4147 fail:
4148 return NULL;
4149 }
4150
4151
4152 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4153 PyObject *resultobj = 0;
4154 wxSystemMetric arg1 ;
4155 wxWindow *arg2 = (wxWindow *) NULL ;
4156 int result;
4157 int val1 ;
4158 int ecode1 = 0 ;
4159 void *argp2 = 0 ;
4160 int res2 = 0 ;
4161 PyObject * obj0 = 0 ;
4162 PyObject * obj1 = 0 ;
4163 char * kwnames[] = {
4164 (char *) "index",(char *) "win", NULL
4165 };
4166
4167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4168 ecode1 = SWIG_AsVal_int(obj0, &val1);
4169 if (!SWIG_IsOK(ecode1)) {
4170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4171 }
4172 arg1 = static_cast< wxSystemMetric >(val1);
4173 if (obj1) {
4174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4175 if (!SWIG_IsOK(res2)) {
4176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4177 }
4178 arg2 = reinterpret_cast< wxWindow * >(argp2);
4179 }
4180 {
4181 if (!wxPyCheckForApp()) SWIG_fail;
4182 PyThreadState* __tstate = wxPyBeginAllowThreads();
4183 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 resultobj = SWIG_From_int(static_cast< int >(result));
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4195 PyObject *resultobj = 0;
4196 wxSystemFeature arg1 ;
4197 bool result;
4198 int val1 ;
4199 int ecode1 = 0 ;
4200 PyObject * obj0 = 0 ;
4201 char * kwnames[] = {
4202 (char *) "index", NULL
4203 };
4204
4205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4206 ecode1 = SWIG_AsVal_int(obj0, &val1);
4207 if (!SWIG_IsOK(ecode1)) {
4208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4209 }
4210 arg1 = static_cast< wxSystemFeature >(val1);
4211 {
4212 if (!wxPyCheckForApp()) SWIG_fail;
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = (bool)wxSystemSettings::HasFeature(arg1);
4215 wxPyEndAllowThreads(__tstate);
4216 if (PyErr_Occurred()) SWIG_fail;
4217 }
4218 {
4219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4220 }
4221 return resultobj;
4222 fail:
4223 return NULL;
4224 }
4225
4226
4227 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4228 PyObject *resultobj = 0;
4229 wxSystemScreenType result;
4230
4231 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4232 {
4233 if (!wxPyCheckForApp()) SWIG_fail;
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 resultobj = SWIG_From_int(static_cast< int >(result));
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4247 PyObject *resultobj = 0;
4248 wxSystemScreenType arg1 ;
4249 int val1 ;
4250 int ecode1 = 0 ;
4251 PyObject * obj0 = 0 ;
4252 char * kwnames[] = {
4253 (char *) "screen", NULL
4254 };
4255
4256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4257 ecode1 = SWIG_AsVal_int(obj0, &val1);
4258 if (!SWIG_IsOK(ecode1)) {
4259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4260 }
4261 arg1 = static_cast< wxSystemScreenType >(val1);
4262 {
4263 if (!wxPyCheckForApp()) SWIG_fail;
4264 PyThreadState* __tstate = wxPyBeginAllowThreads();
4265 wxSystemSettings::SetScreenType(arg1);
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 resultobj = SWIG_Py_Void();
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4277 PyObject *obj;
4278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4279 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4280 return SWIG_Py_Void();
4281 }
4282
4283 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4284 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4285 return 1;
4286 }
4287
4288
4289 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4290 PyObject *pyobj = 0;
4291
4292 {
4293 #if wxUSE_UNICODE
4294 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4295 #else
4296 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4297 #endif
4298 }
4299 return pyobj;
4300 }
4301
4302
4303 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4304 PyObject *resultobj = 0;
4305 wxSystemOptions *result = 0 ;
4306
4307 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = (wxSystemOptions *)new wxSystemOptions();
4311 wxPyEndAllowThreads(__tstate);
4312 if (PyErr_Occurred()) SWIG_fail;
4313 }
4314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj = 0;
4323 wxString *arg1 = 0 ;
4324 wxString *arg2 = 0 ;
4325 bool temp1 = false ;
4326 bool temp2 = false ;
4327 PyObject * obj0 = 0 ;
4328 PyObject * obj1 = 0 ;
4329 char * kwnames[] = {
4330 (char *) "name",(char *) "value", NULL
4331 };
4332
4333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4334 {
4335 arg1 = wxString_in_helper(obj0);
4336 if (arg1 == NULL) SWIG_fail;
4337 temp1 = true;
4338 }
4339 {
4340 arg2 = wxString_in_helper(obj1);
4341 if (arg2 == NULL) SWIG_fail;
4342 temp2 = true;
4343 }
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4347 wxPyEndAllowThreads(__tstate);
4348 if (PyErr_Occurred()) SWIG_fail;
4349 }
4350 resultobj = SWIG_Py_Void();
4351 {
4352 if (temp1)
4353 delete arg1;
4354 }
4355 {
4356 if (temp2)
4357 delete arg2;
4358 }
4359 return resultobj;
4360 fail:
4361 {
4362 if (temp1)
4363 delete arg1;
4364 }
4365 {
4366 if (temp2)
4367 delete arg2;
4368 }
4369 return NULL;
4370 }
4371
4372
4373 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4374 PyObject *resultobj = 0;
4375 wxString *arg1 = 0 ;
4376 int arg2 ;
4377 bool temp1 = false ;
4378 int val2 ;
4379 int ecode2 = 0 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char * kwnames[] = {
4383 (char *) "name",(char *) "value", NULL
4384 };
4385
4386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4387 {
4388 arg1 = wxString_in_helper(obj0);
4389 if (arg1 == NULL) SWIG_fail;
4390 temp1 = true;
4391 }
4392 ecode2 = SWIG_AsVal_int(obj1, &val2);
4393 if (!SWIG_IsOK(ecode2)) {
4394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4395 }
4396 arg2 = static_cast< int >(val2);
4397 {
4398 PyThreadState* __tstate = wxPyBeginAllowThreads();
4399 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 resultobj = SWIG_Py_Void();
4404 {
4405 if (temp1)
4406 delete arg1;
4407 }
4408 return resultobj;
4409 fail:
4410 {
4411 if (temp1)
4412 delete arg1;
4413 }
4414 return NULL;
4415 }
4416
4417
4418 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4419 PyObject *resultobj = 0;
4420 wxString *arg1 = 0 ;
4421 wxString result;
4422 bool temp1 = false ;
4423 PyObject * obj0 = 0 ;
4424 char * kwnames[] = {
4425 (char *) "name", NULL
4426 };
4427
4428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4429 {
4430 arg1 = wxString_in_helper(obj0);
4431 if (arg1 == NULL) SWIG_fail;
4432 temp1 = true;
4433 }
4434 {
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 {
4441 #if wxUSE_UNICODE
4442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4443 #else
4444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4445 #endif
4446 }
4447 {
4448 if (temp1)
4449 delete arg1;
4450 }
4451 return resultobj;
4452 fail:
4453 {
4454 if (temp1)
4455 delete arg1;
4456 }
4457 return NULL;
4458 }
4459
4460
4461 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4462 PyObject *resultobj = 0;
4463 wxString *arg1 = 0 ;
4464 int result;
4465 bool temp1 = false ;
4466 PyObject * obj0 = 0 ;
4467 char * kwnames[] = {
4468 (char *) "name", NULL
4469 };
4470
4471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4472 {
4473 arg1 = wxString_in_helper(obj0);
4474 if (arg1 == NULL) SWIG_fail;
4475 temp1 = true;
4476 }
4477 {
4478 PyThreadState* __tstate = wxPyBeginAllowThreads();
4479 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4480 wxPyEndAllowThreads(__tstate);
4481 if (PyErr_Occurred()) SWIG_fail;
4482 }
4483 resultobj = SWIG_From_int(static_cast< int >(result));
4484 {
4485 if (temp1)
4486 delete arg1;
4487 }
4488 return resultobj;
4489 fail:
4490 {
4491 if (temp1)
4492 delete arg1;
4493 }
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = 0;
4500 wxString *arg1 = 0 ;
4501 bool result;
4502 bool temp1 = false ;
4503 PyObject * obj0 = 0 ;
4504 char * kwnames[] = {
4505 (char *) "name", NULL
4506 };
4507
4508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4509 {
4510 arg1 = wxString_in_helper(obj0);
4511 if (arg1 == NULL) SWIG_fail;
4512 temp1 = true;
4513 }
4514 {
4515 PyThreadState* __tstate = wxPyBeginAllowThreads();
4516 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4517 wxPyEndAllowThreads(__tstate);
4518 if (PyErr_Occurred()) SWIG_fail;
4519 }
4520 {
4521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4522 }
4523 {
4524 if (temp1)
4525 delete arg1;
4526 }
4527 return resultobj;
4528 fail:
4529 {
4530 if (temp1)
4531 delete arg1;
4532 }
4533 return NULL;
4534 }
4535
4536
4537 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4538 PyObject *resultobj = 0;
4539 wxString *arg1 = 0 ;
4540 bool result;
4541 bool temp1 = false ;
4542 PyObject * obj0 = 0 ;
4543 char * kwnames[] = {
4544 (char *) "name", NULL
4545 };
4546
4547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4548 {
4549 arg1 = wxString_in_helper(obj0);
4550 if (arg1 == NULL) SWIG_fail;
4551 temp1 = true;
4552 }
4553 {
4554 PyThreadState* __tstate = wxPyBeginAllowThreads();
4555 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4561 }
4562 {
4563 if (temp1)
4564 delete arg1;
4565 }
4566 return resultobj;
4567 fail:
4568 {
4569 if (temp1)
4570 delete arg1;
4571 }
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4577 PyObject *obj;
4578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4579 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4580 return SWIG_Py_Void();
4581 }
4582
4583 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4584 return SWIG_Python_InitShadowInstance(args);
4585 }
4586
4587 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4588 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4589 return 1;
4590 }
4591
4592
4593 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4594 PyObject *pyobj = 0;
4595
4596 {
4597 #if wxUSE_UNICODE
4598 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4599 #else
4600 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4601 #endif
4602 }
4603 return pyobj;
4604 }
4605
4606
4607 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4608 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4609 return 1;
4610 }
4611
4612
4613 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4614 PyObject *pyobj = 0;
4615
4616 {
4617 #if wxUSE_UNICODE
4618 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4619 #else
4620 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4621 #endif
4622 }
4623 return pyobj;
4624 }
4625
4626
4627 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4628 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4629 return 1;
4630 }
4631
4632
4633 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4634 PyObject *pyobj = 0;
4635
4636 {
4637 #if wxUSE_UNICODE
4638 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4639 #else
4640 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4641 #endif
4642 }
4643 return pyobj;
4644 }
4645
4646
4647 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4648 PyObject *resultobj = 0;
4649 long result;
4650
4651 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4652 {
4653 PyThreadState* __tstate = wxPyBeginAllowThreads();
4654 result = (long)wxNewId();
4655 wxPyEndAllowThreads(__tstate);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 resultobj = SWIG_From_long(static_cast< long >(result));
4659 return resultobj;
4660 fail:
4661 return NULL;
4662 }
4663
4664
4665 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4666 PyObject *resultobj = 0;
4667 long arg1 ;
4668 long val1 ;
4669 int ecode1 = 0 ;
4670 PyObject * obj0 = 0 ;
4671 char * kwnames[] = {
4672 (char *) "id", NULL
4673 };
4674
4675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4676 ecode1 = SWIG_AsVal_long(obj0, &val1);
4677 if (!SWIG_IsOK(ecode1)) {
4678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4679 }
4680 arg1 = static_cast< long >(val1);
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 wxRegisterId(arg1);
4684 wxPyEndAllowThreads(__tstate);
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 resultobj = SWIG_Py_Void();
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4695 PyObject *resultobj = 0;
4696 long result;
4697
4698 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = (long)wxGetCurrentId();
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_From_long(static_cast< long >(result));
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj = 0;
4714 int arg1 ;
4715 bool result;
4716 int val1 ;
4717 int ecode1 = 0 ;
4718 PyObject * obj0 = 0 ;
4719 char * kwnames[] = {
4720 (char *) "id", NULL
4721 };
4722
4723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4724 ecode1 = SWIG_AsVal_int(obj0, &val1);
4725 if (!SWIG_IsOK(ecode1)) {
4726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4727 }
4728 arg1 = static_cast< int >(val1);
4729 {
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = (bool)wxIsStockID(arg1);
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4737 }
4738 return resultobj;
4739 fail:
4740 return NULL;
4741 }
4742
4743
4744 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj = 0;
4746 int arg1 ;
4747 wxString *arg2 = 0 ;
4748 bool result;
4749 int val1 ;
4750 int ecode1 = 0 ;
4751 bool temp2 = false ;
4752 PyObject * obj0 = 0 ;
4753 PyObject * obj1 = 0 ;
4754 char * kwnames[] = {
4755 (char *) "id",(char *) "label", NULL
4756 };
4757
4758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4759 ecode1 = SWIG_AsVal_int(obj0, &val1);
4760 if (!SWIG_IsOK(ecode1)) {
4761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4762 }
4763 arg1 = static_cast< int >(val1);
4764 {
4765 arg2 = wxString_in_helper(obj1);
4766 if (arg2 == NULL) SWIG_fail;
4767 temp2 = true;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 {
4776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4777 }
4778 {
4779 if (temp2)
4780 delete arg2;
4781 }
4782 return resultobj;
4783 fail:
4784 {
4785 if (temp2)
4786 delete arg2;
4787 }
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 int arg1 ;
4795 bool arg2 = (bool) true ;
4796 wxString arg3 = (wxString) wxPyEmptyString ;
4797 wxString result;
4798 int val1 ;
4799 int ecode1 = 0 ;
4800 bool val2 ;
4801 int ecode2 = 0 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 PyObject * obj2 = 0 ;
4805 char * kwnames[] = {
4806 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4807 };
4808
4809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4810 ecode1 = SWIG_AsVal_int(obj0, &val1);
4811 if (!SWIG_IsOK(ecode1)) {
4812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4813 }
4814 arg1 = static_cast< int >(val1);
4815 if (obj1) {
4816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4817 if (!SWIG_IsOK(ecode2)) {
4818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4819 }
4820 arg2 = static_cast< bool >(val2);
4821 }
4822 if (obj2) {
4823 {
4824 wxString* sptr = wxString_in_helper(obj2);
4825 if (sptr == NULL) SWIG_fail;
4826 arg3 = *sptr;
4827 delete sptr;
4828 }
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = wxGetStockLabel(arg1,arg2,arg3);
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 {
4837 #if wxUSE_UNICODE
4838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4839 #else
4840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4841 #endif
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4850 PyObject *resultobj = 0;
4851
4852 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4853 {
4854 if (!wxPyCheckForApp()) SWIG_fail;
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 wxBell();
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 resultobj = SWIG_Py_Void();
4861 return resultobj;
4862 fail:
4863 return NULL;
4864 }
4865
4866
4867 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4868 PyObject *resultobj = 0;
4869
4870 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4871 {
4872 if (!wxPyCheckForApp()) SWIG_fail;
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 wxEndBusyCursor();
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_Py_Void();
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 bool arg1 = (bool) true ;
4888 long result;
4889 bool val1 ;
4890 int ecode1 = 0 ;
4891 PyObject * obj0 = 0 ;
4892 char * kwnames[] = {
4893 (char *) "resetTimer", NULL
4894 };
4895
4896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4897 if (obj0) {
4898 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4899 if (!SWIG_IsOK(ecode1)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4901 }
4902 arg1 = static_cast< bool >(val1);
4903 }
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 result = (long)wxGetElapsedTime(arg1);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_From_long(static_cast< long >(result));
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4918 PyObject *resultobj = 0;
4919 bool result;
4920
4921 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 result = (bool)wxIsBusy();
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 {
4929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4930 }
4931 return resultobj;
4932 fail:
4933 return NULL;
4934 }
4935
4936
4937 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4938 PyObject *resultobj = 0;
4939 wxString result;
4940
4941 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = wxNow();
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 {
4949 #if wxUSE_UNICODE
4950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4951 #else
4952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4953 #endif
4954 }
4955 return resultobj;
4956 fail:
4957 return NULL;
4958 }
4959
4960
4961 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4962 PyObject *resultobj = 0;
4963 wxString const &arg1_defvalue = wxPyEmptyString ;
4964 wxString *arg1 = (wxString *) &arg1_defvalue ;
4965 bool result;
4966 bool temp1 = false ;
4967 PyObject * obj0 = 0 ;
4968 char * kwnames[] = {
4969 (char *) "command", NULL
4970 };
4971
4972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4973 if (obj0) {
4974 {
4975 arg1 = wxString_in_helper(obj0);
4976 if (arg1 == NULL) SWIG_fail;
4977 temp1 = true;
4978 }
4979 }
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 result = (bool)wxShell((wxString const &)*arg1);
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4988 }
4989 {
4990 if (temp1)
4991 delete arg1;
4992 }
4993 return resultobj;
4994 fail:
4995 {
4996 if (temp1)
4997 delete arg1;
4998 }
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5004 PyObject *resultobj = 0;
5005
5006 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 wxStartTimer();
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5021 PyObject *resultobj = 0;
5022 int *arg1 = (int *) 0 ;
5023 int *arg2 = (int *) 0 ;
5024 int result;
5025 int temp1 ;
5026 int res1 = SWIG_TMPOBJ ;
5027 int temp2 ;
5028 int res2 = SWIG_TMPOBJ ;
5029
5030 arg1 = &temp1;
5031 arg2 = &temp2;
5032 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5033 {
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = (int)wxGetOsVersion(arg1,arg2);
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 resultobj = SWIG_From_int(static_cast< int >(result));
5040 if (SWIG_IsTmpObj(res1)) {
5041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5042 } else {
5043 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5045 }
5046 if (SWIG_IsTmpObj(res2)) {
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5048 } else {
5049 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059 PyObject *resultobj = 0;
5060 wxString result;
5061
5062 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = wxGetOsDescription();
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 {
5070 #if wxUSE_UNICODE
5071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5072 #else
5073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5074 #endif
5075 }
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5083 PyObject *resultobj = 0;
5084 wxMemorySize result;
5085
5086 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = wxGetFreeMemory();
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5101 PyObject *resultobj = 0;
5102 wxShutdownFlags arg1 ;
5103 bool result;
5104 int val1 ;
5105 int ecode1 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 char * kwnames[] = {
5108 (char *) "wFlags", NULL
5109 };
5110
5111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5112 ecode1 = SWIG_AsVal_int(obj0, &val1);
5113 if (!SWIG_IsOK(ecode1)) {
5114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5115 }
5116 arg1 = static_cast< wxShutdownFlags >(val1);
5117 {
5118 if (!wxPyCheckForApp()) SWIG_fail;
5119 PyThreadState* __tstate = wxPyBeginAllowThreads();
5120 result = (bool)wxShutdown(arg1);
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 {
5125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5126 }
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5134 PyObject *resultobj = 0;
5135 int arg1 ;
5136 int val1 ;
5137 int ecode1 = 0 ;
5138 PyObject * obj0 = 0 ;
5139 char * kwnames[] = {
5140 (char *) "secs", NULL
5141 };
5142
5143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5144 ecode1 = SWIG_AsVal_int(obj0, &val1);
5145 if (!SWIG_IsOK(ecode1)) {
5146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5147 }
5148 arg1 = static_cast< int >(val1);
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 wxSleep(arg1);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 unsigned long arg1 ;
5165 unsigned long val1 ;
5166 int ecode1 = 0 ;
5167 PyObject * obj0 = 0 ;
5168 char * kwnames[] = {
5169 (char *) "milliseconds", NULL
5170 };
5171
5172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5173 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5174 if (!SWIG_IsOK(ecode1)) {
5175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5176 }
5177 arg1 = static_cast< unsigned long >(val1);
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 wxMilliSleep(arg1);
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 resultobj = SWIG_Py_Void();
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj = 0;
5193 unsigned long arg1 ;
5194 unsigned long val1 ;
5195 int ecode1 = 0 ;
5196 PyObject * obj0 = 0 ;
5197 char * kwnames[] = {
5198 (char *) "microseconds", NULL
5199 };
5200
5201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5202 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5203 if (!SWIG_IsOK(ecode1)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5205 }
5206 arg1 = static_cast< unsigned long >(val1);
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 wxMicroSleep(arg1);
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_Py_Void();
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 bool arg1 ;
5223 bool val1 ;
5224 int ecode1 = 0 ;
5225 PyObject * obj0 = 0 ;
5226 char * kwnames[] = {
5227 (char *) "enable", NULL
5228 };
5229
5230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5231 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5232 if (!SWIG_IsOK(ecode1)) {
5233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5234 }
5235 arg1 = static_cast< bool >(val1);
5236 {
5237 PyThreadState* __tstate = wxPyBeginAllowThreads();
5238 wxEnableTopLevelWindows(arg1);
5239 wxPyEndAllowThreads(__tstate);
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 resultobj = SWIG_Py_Void();
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj = 0;
5251 wxString *arg1 = 0 ;
5252 wxString result;
5253 bool temp1 = false ;
5254 PyObject * obj0 = 0 ;
5255 char * kwnames[] = {
5256 (char *) "in", NULL
5257 };
5258
5259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5260 {
5261 arg1 = wxString_in_helper(obj0);
5262 if (arg1 == NULL) SWIG_fail;
5263 temp1 = true;
5264 }
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = wxStripMenuCodes((wxString const &)*arg1);
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 #if wxUSE_UNICODE
5273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5274 #else
5275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5276 #endif
5277 }
5278 {
5279 if (temp1)
5280 delete arg1;
5281 }
5282 return resultobj;
5283 fail:
5284 {
5285 if (temp1)
5286 delete arg1;
5287 }
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 PyObject *resultobj = 0;
5294 wxString result;
5295
5296 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5297 {
5298 PyThreadState* __tstate = wxPyBeginAllowThreads();
5299 result = wxGetEmailAddress();
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 {
5304 #if wxUSE_UNICODE
5305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5306 #else
5307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5308 #endif
5309 }
5310 return resultobj;
5311 fail:
5312 return NULL;
5313 }
5314
5315
5316 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5317 PyObject *resultobj = 0;
5318 wxString result;
5319
5320 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = wxGetHostName();
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 {
5328 #if wxUSE_UNICODE
5329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5330 #else
5331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5332 #endif
5333 }
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5341 PyObject *resultobj = 0;
5342 wxString result;
5343
5344 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = wxGetFullHostName();
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 #if wxUSE_UNICODE
5353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5354 #else
5355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5356 #endif
5357 }
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxString result;
5367
5368 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 result = wxGetUserId();
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 {
5376 #if wxUSE_UNICODE
5377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5378 #else
5379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5380 #endif
5381 }
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5389 PyObject *resultobj = 0;
5390 wxString result;
5391
5392 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5393 {
5394 PyThreadState* __tstate = wxPyBeginAllowThreads();
5395 result = wxGetUserName();
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 #if wxUSE_UNICODE
5401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5402 #else
5403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5404 #endif
5405 }
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *resultobj = 0;
5414 wxString result;
5415
5416 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = wxGetHomeDir();
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 #if wxUSE_UNICODE
5425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5426 #else
5427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5428 #endif
5429 }
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5437 PyObject *resultobj = 0;
5438 wxString const &arg1_defvalue = wxPyEmptyString ;
5439 wxString *arg1 = (wxString *) &arg1_defvalue ;
5440 wxString result;
5441 bool temp1 = false ;
5442 PyObject * obj0 = 0 ;
5443 char * kwnames[] = {
5444 (char *) "user", NULL
5445 };
5446
5447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5448 if (obj0) {
5449 {
5450 arg1 = wxString_in_helper(obj0);
5451 if (arg1 == NULL) SWIG_fail;
5452 temp1 = true;
5453 }
5454 }
5455 {
5456 PyThreadState* __tstate = wxPyBeginAllowThreads();
5457 result = wxGetUserHome((wxString const &)*arg1);
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 {
5462 #if wxUSE_UNICODE
5463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5464 #else
5465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5466 #endif
5467 }
5468 {
5469 if (temp1)
5470 delete arg1;
5471 }
5472 return resultobj;
5473 fail:
5474 {
5475 if (temp1)
5476 delete arg1;
5477 }
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 unsigned long result;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (unsigned long)wxGetProcessId();
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502
5503 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 wxTrap();
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_Py_Void();
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5520 wxString *arg1 = (wxString *) &arg1_defvalue ;
5521 wxString const &arg2_defvalue = wxPyEmptyString ;
5522 wxString *arg2 = (wxString *) &arg2_defvalue ;
5523 wxString const &arg3_defvalue = wxPyEmptyString ;
5524 wxString *arg3 = (wxString *) &arg3_defvalue ;
5525 wxString const &arg4_defvalue = wxPyEmptyString ;
5526 wxString *arg4 = (wxString *) &arg4_defvalue ;
5527 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5528 wxString *arg5 = (wxString *) &arg5_defvalue ;
5529 int arg6 = (int) 0 ;
5530 wxWindow *arg7 = (wxWindow *) NULL ;
5531 int arg8 = (int) -1 ;
5532 int arg9 = (int) -1 ;
5533 wxString result;
5534 bool temp1 = false ;
5535 bool temp2 = false ;
5536 bool temp3 = false ;
5537 bool temp4 = false ;
5538 bool temp5 = false ;
5539 int val6 ;
5540 int ecode6 = 0 ;
5541 void *argp7 = 0 ;
5542 int res7 = 0 ;
5543 int val8 ;
5544 int ecode8 = 0 ;
5545 int val9 ;
5546 int ecode9 = 0 ;
5547 PyObject * obj0 = 0 ;
5548 PyObject * obj1 = 0 ;
5549 PyObject * obj2 = 0 ;
5550 PyObject * obj3 = 0 ;
5551 PyObject * obj4 = 0 ;
5552 PyObject * obj5 = 0 ;
5553 PyObject * obj6 = 0 ;
5554 PyObject * obj7 = 0 ;
5555 PyObject * obj8 = 0 ;
5556 char * kwnames[] = {
5557 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5558 };
5559
5560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5561 if (obj0) {
5562 {
5563 arg1 = wxString_in_helper(obj0);
5564 if (arg1 == NULL) SWIG_fail;
5565 temp1 = true;
5566 }
5567 }
5568 if (obj1) {
5569 {
5570 arg2 = wxString_in_helper(obj1);
5571 if (arg2 == NULL) SWIG_fail;
5572 temp2 = true;
5573 }
5574 }
5575 if (obj2) {
5576 {
5577 arg3 = wxString_in_helper(obj2);
5578 if (arg3 == NULL) SWIG_fail;
5579 temp3 = true;
5580 }
5581 }
5582 if (obj3) {
5583 {
5584 arg4 = wxString_in_helper(obj3);
5585 if (arg4 == NULL) SWIG_fail;
5586 temp4 = true;
5587 }
5588 }
5589 if (obj4) {
5590 {
5591 arg5 = wxString_in_helper(obj4);
5592 if (arg5 == NULL) SWIG_fail;
5593 temp5 = true;
5594 }
5595 }
5596 if (obj5) {
5597 ecode6 = SWIG_AsVal_int(obj5, &val6);
5598 if (!SWIG_IsOK(ecode6)) {
5599 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5600 }
5601 arg6 = static_cast< int >(val6);
5602 }
5603 if (obj6) {
5604 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5605 if (!SWIG_IsOK(res7)) {
5606 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5607 }
5608 arg7 = reinterpret_cast< wxWindow * >(argp7);
5609 }
5610 if (obj7) {
5611 ecode8 = SWIG_AsVal_int(obj7, &val8);
5612 if (!SWIG_IsOK(ecode8)) {
5613 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5614 }
5615 arg8 = static_cast< int >(val8);
5616 }
5617 if (obj8) {
5618 ecode9 = SWIG_AsVal_int(obj8, &val9);
5619 if (!SWIG_IsOK(ecode9)) {
5620 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5621 }
5622 arg9 = static_cast< int >(val9);
5623 }
5624 {
5625 if (!wxPyCheckForApp()) SWIG_fail;
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 {
5632 #if wxUSE_UNICODE
5633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5634 #else
5635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5636 #endif
5637 }
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 resultobj;
5659 fail:
5660 {
5661 if (temp1)
5662 delete arg1;
5663 }
5664 {
5665 if (temp2)
5666 delete arg2;
5667 }
5668 {
5669 if (temp3)
5670 delete arg3;
5671 }
5672 {
5673 if (temp4)
5674 delete arg4;
5675 }
5676 {
5677 if (temp5)
5678 delete arg5;
5679 }
5680 return NULL;
5681 }
5682
5683
5684 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5685 PyObject *resultobj = 0;
5686 wxString *arg1 = 0 ;
5687 wxString *arg2 = 0 ;
5688 wxString const &arg3_defvalue = wxPyEmptyString ;
5689 wxString *arg3 = (wxString *) &arg3_defvalue ;
5690 wxWindow *arg4 = (wxWindow *) NULL ;
5691 wxString result;
5692 bool temp1 = false ;
5693 bool temp2 = false ;
5694 bool temp3 = false ;
5695 void *argp4 = 0 ;
5696 int res4 = 0 ;
5697 PyObject * obj0 = 0 ;
5698 PyObject * obj1 = 0 ;
5699 PyObject * obj2 = 0 ;
5700 PyObject * obj3 = 0 ;
5701 char * kwnames[] = {
5702 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5703 };
5704
5705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5706 {
5707 arg1 = wxString_in_helper(obj0);
5708 if (arg1 == NULL) SWIG_fail;
5709 temp1 = true;
5710 }
5711 {
5712 arg2 = wxString_in_helper(obj1);
5713 if (arg2 == NULL) SWIG_fail;
5714 temp2 = true;
5715 }
5716 if (obj2) {
5717 {
5718 arg3 = wxString_in_helper(obj2);
5719 if (arg3 == NULL) SWIG_fail;
5720 temp3 = true;
5721 }
5722 }
5723 if (obj3) {
5724 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5725 if (!SWIG_IsOK(res4)) {
5726 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5727 }
5728 arg4 = reinterpret_cast< wxWindow * >(argp4);
5729 }
5730 {
5731 if (!wxPyCheckForApp()) SWIG_fail;
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5734 wxPyEndAllowThreads(__tstate);
5735 if (PyErr_Occurred()) SWIG_fail;
5736 }
5737 {
5738 #if wxUSE_UNICODE
5739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5740 #else
5741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5742 #endif
5743 }
5744 {
5745 if (temp1)
5746 delete arg1;
5747 }
5748 {
5749 if (temp2)
5750 delete arg2;
5751 }
5752 {
5753 if (temp3)
5754 delete arg3;
5755 }
5756 return resultobj;
5757 fail:
5758 {
5759 if (temp1)
5760 delete arg1;
5761 }
5762 {
5763 if (temp2)
5764 delete arg2;
5765 }
5766 {
5767 if (temp3)
5768 delete arg3;
5769 }
5770 return NULL;
5771 }
5772
5773
5774 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5775 PyObject *resultobj = 0;
5776 wxString *arg1 = 0 ;
5777 wxString *arg2 = 0 ;
5778 wxString const &arg3_defvalue = wxPyEmptyString ;
5779 wxString *arg3 = (wxString *) &arg3_defvalue ;
5780 wxWindow *arg4 = (wxWindow *) NULL ;
5781 wxString result;
5782 bool temp1 = false ;
5783 bool temp2 = false ;
5784 bool temp3 = false ;
5785 void *argp4 = 0 ;
5786 int res4 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 PyObject * obj2 = 0 ;
5790 PyObject * obj3 = 0 ;
5791 char * kwnames[] = {
5792 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5793 };
5794
5795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5796 {
5797 arg1 = wxString_in_helper(obj0);
5798 if (arg1 == NULL) SWIG_fail;
5799 temp1 = true;
5800 }
5801 {
5802 arg2 = wxString_in_helper(obj1);
5803 if (arg2 == NULL) SWIG_fail;
5804 temp2 = true;
5805 }
5806 if (obj2) {
5807 {
5808 arg3 = wxString_in_helper(obj2);
5809 if (arg3 == NULL) SWIG_fail;
5810 temp3 = true;
5811 }
5812 }
5813 if (obj3) {
5814 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5815 if (!SWIG_IsOK(res4)) {
5816 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5817 }
5818 arg4 = reinterpret_cast< wxWindow * >(argp4);
5819 }
5820 {
5821 if (!wxPyCheckForApp()) SWIG_fail;
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 {
5828 #if wxUSE_UNICODE
5829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5830 #else
5831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5832 #endif
5833 }
5834 {
5835 if (temp1)
5836 delete arg1;
5837 }
5838 {
5839 if (temp2)
5840 delete arg2;
5841 }
5842 {
5843 if (temp3)
5844 delete arg3;
5845 }
5846 return resultobj;
5847 fail:
5848 {
5849 if (temp1)
5850 delete arg1;
5851 }
5852 {
5853 if (temp2)
5854 delete arg2;
5855 }
5856 {
5857 if (temp3)
5858 delete arg3;
5859 }
5860 return NULL;
5861 }
5862
5863
5864 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj = 0;
5866 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5867 wxString *arg1 = (wxString *) &arg1_defvalue ;
5868 wxString const &arg2_defvalue = wxPyEmptyString ;
5869 wxString *arg2 = (wxString *) &arg2_defvalue ;
5870 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5871 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5872 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5873 wxWindow *arg5 = (wxWindow *) NULL ;
5874 wxString result;
5875 bool temp1 = false ;
5876 bool temp2 = false ;
5877 long val3 ;
5878 int ecode3 = 0 ;
5879 wxPoint temp4 ;
5880 void *argp5 = 0 ;
5881 int res5 = 0 ;
5882 PyObject * obj0 = 0 ;
5883 PyObject * obj1 = 0 ;
5884 PyObject * obj2 = 0 ;
5885 PyObject * obj3 = 0 ;
5886 PyObject * obj4 = 0 ;
5887 char * kwnames[] = {
5888 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5889 };
5890
5891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5892 if (obj0) {
5893 {
5894 arg1 = wxString_in_helper(obj0);
5895 if (arg1 == NULL) SWIG_fail;
5896 temp1 = true;
5897 }
5898 }
5899 if (obj1) {
5900 {
5901 arg2 = wxString_in_helper(obj1);
5902 if (arg2 == NULL) SWIG_fail;
5903 temp2 = true;
5904 }
5905 }
5906 if (obj2) {
5907 ecode3 = SWIG_AsVal_long(obj2, &val3);
5908 if (!SWIG_IsOK(ecode3)) {
5909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5910 }
5911 arg3 = static_cast< long >(val3);
5912 }
5913 if (obj3) {
5914 {
5915 arg4 = &temp4;
5916 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5917 }
5918 }
5919 if (obj4) {
5920 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5921 if (!SWIG_IsOK(res5)) {
5922 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5923 }
5924 arg5 = reinterpret_cast< wxWindow * >(argp5);
5925 }
5926 {
5927 if (!wxPyCheckForApp()) SWIG_fail;
5928 PyThreadState* __tstate = wxPyBeginAllowThreads();
5929 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 {
5934 #if wxUSE_UNICODE
5935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5936 #else
5937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5938 #endif
5939 }
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 {
5945 if (temp2)
5946 delete arg2;
5947 }
5948 return resultobj;
5949 fail:
5950 {
5951 if (temp1)
5952 delete arg1;
5953 }
5954 {
5955 if (temp2)
5956 delete arg2;
5957 }
5958 return NULL;
5959 }
5960
5961
5962 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj = 0;
5964 wxString *arg1 = 0 ;
5965 wxString const &arg2_defvalue = wxPyEmptyString ;
5966 wxString *arg2 = (wxString *) &arg2_defvalue ;
5967 wxString const &arg3_defvalue = wxPyEmptyString ;
5968 wxString *arg3 = (wxString *) &arg3_defvalue ;
5969 wxWindow *arg4 = (wxWindow *) NULL ;
5970 int arg5 = (int) -1 ;
5971 int arg6 = (int) -1 ;
5972 bool arg7 = (bool) true ;
5973 wxString result;
5974 bool temp1 = false ;
5975 bool temp2 = false ;
5976 bool temp3 = false ;
5977 void *argp4 = 0 ;
5978 int res4 = 0 ;
5979 int val5 ;
5980 int ecode5 = 0 ;
5981 int val6 ;
5982 int ecode6 = 0 ;
5983 bool val7 ;
5984 int ecode7 = 0 ;
5985 PyObject * obj0 = 0 ;
5986 PyObject * obj1 = 0 ;
5987 PyObject * obj2 = 0 ;
5988 PyObject * obj3 = 0 ;
5989 PyObject * obj4 = 0 ;
5990 PyObject * obj5 = 0 ;
5991 PyObject * obj6 = 0 ;
5992 char * kwnames[] = {
5993 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5994 };
5995
5996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5997 {
5998 arg1 = wxString_in_helper(obj0);
5999 if (arg1 == NULL) SWIG_fail;
6000 temp1 = true;
6001 }
6002 if (obj1) {
6003 {
6004 arg2 = wxString_in_helper(obj1);
6005 if (arg2 == NULL) SWIG_fail;
6006 temp2 = true;
6007 }
6008 }
6009 if (obj2) {
6010 {
6011 arg3 = wxString_in_helper(obj2);
6012 if (arg3 == NULL) SWIG_fail;
6013 temp3 = true;
6014 }
6015 }
6016 if (obj3) {
6017 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6018 if (!SWIG_IsOK(res4)) {
6019 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6020 }
6021 arg4 = reinterpret_cast< wxWindow * >(argp4);
6022 }
6023 if (obj4) {
6024 ecode5 = SWIG_AsVal_int(obj4, &val5);
6025 if (!SWIG_IsOK(ecode5)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6027 }
6028 arg5 = static_cast< int >(val5);
6029 }
6030 if (obj5) {
6031 ecode6 = SWIG_AsVal_int(obj5, &val6);
6032 if (!SWIG_IsOK(ecode6)) {
6033 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6034 }
6035 arg6 = static_cast< int >(val6);
6036 }
6037 if (obj6) {
6038 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6039 if (!SWIG_IsOK(ecode7)) {
6040 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6041 }
6042 arg7 = static_cast< bool >(val7);
6043 }
6044 {
6045 if (!wxPyCheckForApp()) SWIG_fail;
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 #if wxUSE_UNICODE
6053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6054 #else
6055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6056 #endif
6057 }
6058 {
6059 if (temp1)
6060 delete arg1;
6061 }
6062 {
6063 if (temp2)
6064 delete arg2;
6065 }
6066 {
6067 if (temp3)
6068 delete arg3;
6069 }
6070 return resultobj;
6071 fail:
6072 {
6073 if (temp1)
6074 delete arg1;
6075 }
6076 {
6077 if (temp2)
6078 delete arg2;
6079 }
6080 {
6081 if (temp3)
6082 delete arg3;
6083 }
6084 return NULL;
6085 }
6086
6087
6088 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6089 PyObject *resultobj = 0;
6090 wxString *arg1 = 0 ;
6091 wxString const &arg2_defvalue = wxPyEmptyString ;
6092 wxString *arg2 = (wxString *) &arg2_defvalue ;
6093 wxString const &arg3_defvalue = wxPyEmptyString ;
6094 wxString *arg3 = (wxString *) &arg3_defvalue ;
6095 wxWindow *arg4 = (wxWindow *) NULL ;
6096 wxString result;
6097 bool temp1 = false ;
6098 bool temp2 = false ;
6099 bool temp3 = false ;
6100 void *argp4 = 0 ;
6101 int res4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 {
6112 arg1 = wxString_in_helper(obj0);
6113 if (arg1 == NULL) SWIG_fail;
6114 temp1 = true;
6115 }
6116 if (obj1) {
6117 {
6118 arg2 = wxString_in_helper(obj1);
6119 if (arg2 == NULL) SWIG_fail;
6120 temp2 = true;
6121 }
6122 }
6123 if (obj2) {
6124 {
6125 arg3 = wxString_in_helper(obj2);
6126 if (arg3 == NULL) SWIG_fail;
6127 temp3 = true;
6128 }
6129 }
6130 if (obj3) {
6131 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6132 if (!SWIG_IsOK(res4)) {
6133 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6134 }
6135 arg4 = reinterpret_cast< wxWindow * >(argp4);
6136 }
6137 {
6138 if (!wxPyCheckForApp()) SWIG_fail;
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 {
6145 #if wxUSE_UNICODE
6146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6147 #else
6148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6149 #endif
6150 }
6151 {
6152 if (temp1)
6153 delete arg1;
6154 }
6155 {
6156 if (temp2)
6157 delete arg2;
6158 }
6159 {
6160 if (temp3)
6161 delete arg3;
6162 }
6163 return resultobj;
6164 fail:
6165 {
6166 if (temp1)
6167 delete arg1;
6168 }
6169 {
6170 if (temp2)
6171 delete arg2;
6172 }
6173 {
6174 if (temp3)
6175 delete arg3;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 wxString *arg1 = 0 ;
6184 wxString *arg2 = 0 ;
6185 int arg3 ;
6186 wxString *arg4 = (wxString *) 0 ;
6187 wxWindow *arg5 = (wxWindow *) NULL ;
6188 int arg6 = (int) -1 ;
6189 int arg7 = (int) -1 ;
6190 bool arg8 = (bool) true ;
6191 int arg9 = (int) 150 ;
6192 int arg10 = (int) 200 ;
6193 wxString result;
6194 bool temp1 = false ;
6195 bool temp2 = false ;
6196 void *argp5 = 0 ;
6197 int res5 = 0 ;
6198 int val6 ;
6199 int ecode6 = 0 ;
6200 int val7 ;
6201 int ecode7 = 0 ;
6202 bool val8 ;
6203 int ecode8 = 0 ;
6204 int val9 ;
6205 int ecode9 = 0 ;
6206 int val10 ;
6207 int ecode10 = 0 ;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 PyObject * obj2 = 0 ;
6211 PyObject * obj3 = 0 ;
6212 PyObject * obj4 = 0 ;
6213 PyObject * obj5 = 0 ;
6214 PyObject * obj6 = 0 ;
6215 PyObject * obj7 = 0 ;
6216 PyObject * obj8 = 0 ;
6217 char * kwnames[] = {
6218 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6219 };
6220
6221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6222 {
6223 arg1 = wxString_in_helper(obj0);
6224 if (arg1 == NULL) SWIG_fail;
6225 temp1 = true;
6226 }
6227 {
6228 arg2 = wxString_in_helper(obj1);
6229 if (arg2 == NULL) SWIG_fail;
6230 temp2 = true;
6231 }
6232 {
6233 arg3 = PyList_Size(obj2);
6234 arg4 = wxString_LIST_helper(obj2);
6235 if (arg4 == NULL) SWIG_fail;
6236 }
6237 if (obj3) {
6238 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6239 if (!SWIG_IsOK(res5)) {
6240 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6241 }
6242 arg5 = reinterpret_cast< wxWindow * >(argp5);
6243 }
6244 if (obj4) {
6245 ecode6 = SWIG_AsVal_int(obj4, &val6);
6246 if (!SWIG_IsOK(ecode6)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6248 }
6249 arg6 = static_cast< int >(val6);
6250 }
6251 if (obj5) {
6252 ecode7 = SWIG_AsVal_int(obj5, &val7);
6253 if (!SWIG_IsOK(ecode7)) {
6254 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6255 }
6256 arg7 = static_cast< int >(val7);
6257 }
6258 if (obj6) {
6259 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6260 if (!SWIG_IsOK(ecode8)) {
6261 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6262 }
6263 arg8 = static_cast< bool >(val8);
6264 }
6265 if (obj7) {
6266 ecode9 = SWIG_AsVal_int(obj7, &val9);
6267 if (!SWIG_IsOK(ecode9)) {
6268 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6269 }
6270 arg9 = static_cast< int >(val9);
6271 }
6272 if (obj8) {
6273 ecode10 = SWIG_AsVal_int(obj8, &val10);
6274 if (!SWIG_IsOK(ecode10)) {
6275 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6276 }
6277 arg10 = static_cast< int >(val10);
6278 }
6279 {
6280 if (!wxPyCheckForApp()) SWIG_fail;
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 #if wxUSE_UNICODE
6288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6289 #else
6290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6291 #endif
6292 }
6293 {
6294 if (temp1)
6295 delete arg1;
6296 }
6297 {
6298 if (temp2)
6299 delete arg2;
6300 }
6301 {
6302 if (arg4) delete [] arg4;
6303 }
6304 return resultobj;
6305 fail:
6306 {
6307 if (temp1)
6308 delete arg1;
6309 }
6310 {
6311 if (temp2)
6312 delete arg2;
6313 }
6314 {
6315 if (arg4) delete [] arg4;
6316 }
6317 return NULL;
6318 }
6319
6320
6321 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj = 0;
6323 wxString *arg1 = 0 ;
6324 wxString *arg2 = 0 ;
6325 int arg3 ;
6326 wxString *arg4 = (wxString *) 0 ;
6327 wxWindow *arg5 = (wxWindow *) NULL ;
6328 int arg6 = (int) -1 ;
6329 int arg7 = (int) -1 ;
6330 bool arg8 = (bool) true ;
6331 int arg9 = (int) 150 ;
6332 int arg10 = (int) 200 ;
6333 int result;
6334 bool temp1 = false ;
6335 bool temp2 = false ;
6336 void *argp5 = 0 ;
6337 int res5 = 0 ;
6338 int val6 ;
6339 int ecode6 = 0 ;
6340 int val7 ;
6341 int ecode7 = 0 ;
6342 bool val8 ;
6343 int ecode8 = 0 ;
6344 int val9 ;
6345 int ecode9 = 0 ;
6346 int val10 ;
6347 int ecode10 = 0 ;
6348 PyObject * obj0 = 0 ;
6349 PyObject * obj1 = 0 ;
6350 PyObject * obj2 = 0 ;
6351 PyObject * obj3 = 0 ;
6352 PyObject * obj4 = 0 ;
6353 PyObject * obj5 = 0 ;
6354 PyObject * obj6 = 0 ;
6355 PyObject * obj7 = 0 ;
6356 PyObject * obj8 = 0 ;
6357 char * kwnames[] = {
6358 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6359 };
6360
6361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6362 {
6363 arg1 = wxString_in_helper(obj0);
6364 if (arg1 == NULL) SWIG_fail;
6365 temp1 = true;
6366 }
6367 {
6368 arg2 = wxString_in_helper(obj1);
6369 if (arg2 == NULL) SWIG_fail;
6370 temp2 = true;
6371 }
6372 {
6373 arg3 = PyList_Size(obj2);
6374 arg4 = wxString_LIST_helper(obj2);
6375 if (arg4 == NULL) SWIG_fail;
6376 }
6377 if (obj3) {
6378 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6379 if (!SWIG_IsOK(res5)) {
6380 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6381 }
6382 arg5 = reinterpret_cast< wxWindow * >(argp5);
6383 }
6384 if (obj4) {
6385 ecode6 = SWIG_AsVal_int(obj4, &val6);
6386 if (!SWIG_IsOK(ecode6)) {
6387 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6388 }
6389 arg6 = static_cast< int >(val6);
6390 }
6391 if (obj5) {
6392 ecode7 = SWIG_AsVal_int(obj5, &val7);
6393 if (!SWIG_IsOK(ecode7)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6395 }
6396 arg7 = static_cast< int >(val7);
6397 }
6398 if (obj6) {
6399 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6400 if (!SWIG_IsOK(ecode8)) {
6401 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6402 }
6403 arg8 = static_cast< bool >(val8);
6404 }
6405 if (obj7) {
6406 ecode9 = SWIG_AsVal_int(obj7, &val9);
6407 if (!SWIG_IsOK(ecode9)) {
6408 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6409 }
6410 arg9 = static_cast< int >(val9);
6411 }
6412 if (obj8) {
6413 ecode10 = SWIG_AsVal_int(obj8, &val10);
6414 if (!SWIG_IsOK(ecode10)) {
6415 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6416 }
6417 arg10 = static_cast< int >(val10);
6418 }
6419 {
6420 if (!wxPyCheckForApp()) SWIG_fail;
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = SWIG_From_int(static_cast< int >(result));
6427 {
6428 if (temp1)
6429 delete arg1;
6430 }
6431 {
6432 if (temp2)
6433 delete arg2;
6434 }
6435 {
6436 if (arg4) delete [] arg4;
6437 }
6438 return resultobj;
6439 fail:
6440 {
6441 if (temp1)
6442 delete arg1;
6443 }
6444 {
6445 if (temp2)
6446 delete arg2;
6447 }
6448 {
6449 if (arg4) delete [] arg4;
6450 }
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj = 0;
6457 wxString *arg1 = 0 ;
6458 wxString const &arg2_defvalue = wxPyEmptyString ;
6459 wxString *arg2 = (wxString *) &arg2_defvalue ;
6460 int arg3 = (int) wxOK|wxCENTRE ;
6461 wxWindow *arg4 = (wxWindow *) NULL ;
6462 int arg5 = (int) -1 ;
6463 int arg6 = (int) -1 ;
6464 int result;
6465 bool temp1 = false ;
6466 bool temp2 = false ;
6467 int val3 ;
6468 int ecode3 = 0 ;
6469 void *argp4 = 0 ;
6470 int res4 = 0 ;
6471 int val5 ;
6472 int ecode5 = 0 ;
6473 int val6 ;
6474 int ecode6 = 0 ;
6475 PyObject * obj0 = 0 ;
6476 PyObject * obj1 = 0 ;
6477 PyObject * obj2 = 0 ;
6478 PyObject * obj3 = 0 ;
6479 PyObject * obj4 = 0 ;
6480 PyObject * obj5 = 0 ;
6481 char * kwnames[] = {
6482 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6483 };
6484
6485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6486 {
6487 arg1 = wxString_in_helper(obj0);
6488 if (arg1 == NULL) SWIG_fail;
6489 temp1 = true;
6490 }
6491 if (obj1) {
6492 {
6493 arg2 = wxString_in_helper(obj1);
6494 if (arg2 == NULL) SWIG_fail;
6495 temp2 = true;
6496 }
6497 }
6498 if (obj2) {
6499 ecode3 = SWIG_AsVal_int(obj2, &val3);
6500 if (!SWIG_IsOK(ecode3)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6502 }
6503 arg3 = static_cast< int >(val3);
6504 }
6505 if (obj3) {
6506 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6507 if (!SWIG_IsOK(res4)) {
6508 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6509 }
6510 arg4 = reinterpret_cast< wxWindow * >(argp4);
6511 }
6512 if (obj4) {
6513 ecode5 = SWIG_AsVal_int(obj4, &val5);
6514 if (!SWIG_IsOK(ecode5)) {
6515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6516 }
6517 arg5 = static_cast< int >(val5);
6518 }
6519 if (obj5) {
6520 ecode6 = SWIG_AsVal_int(obj5, &val6);
6521 if (!SWIG_IsOK(ecode6)) {
6522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6523 }
6524 arg6 = static_cast< int >(val6);
6525 }
6526 {
6527 if (!wxPyCheckForApp()) SWIG_fail;
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 resultobj = SWIG_From_int(static_cast< int >(result));
6534 {
6535 if (temp1)
6536 delete arg1;
6537 }
6538 {
6539 if (temp2)
6540 delete arg2;
6541 }
6542 return resultobj;
6543 fail:
6544 {
6545 if (temp1)
6546 delete arg1;
6547 }
6548 {
6549 if (temp2)
6550 delete arg2;
6551 }
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 bool result;
6559
6560 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6561 {
6562 if (!wxPyCheckForApp()) SWIG_fail;
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 result = (bool)wxColourDisplay();
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 {
6569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6570 }
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6578 PyObject *resultobj = 0;
6579 int result;
6580
6581 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6582 {
6583 if (!wxPyCheckForApp()) SWIG_fail;
6584 PyThreadState* __tstate = wxPyBeginAllowThreads();
6585 result = (int)wxDisplayDepth();
6586 wxPyEndAllowThreads(__tstate);
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 resultobj = SWIG_From_int(static_cast< int >(result));
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6597 PyObject *resultobj = 0;
6598 int result;
6599
6600 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6601 {
6602 if (!wxPyCheckForApp()) SWIG_fail;
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = (int)wxGetDisplayDepth();
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 resultobj = SWIG_From_int(static_cast< int >(result));
6609 return resultobj;
6610 fail:
6611 return NULL;
6612 }
6613
6614
6615 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6616 PyObject *resultobj = 0;
6617 int *arg1 = (int *) 0 ;
6618 int *arg2 = (int *) 0 ;
6619 int temp1 ;
6620 int res1 = SWIG_TMPOBJ ;
6621 int temp2 ;
6622 int res2 = SWIG_TMPOBJ ;
6623
6624 arg1 = &temp1;
6625 arg2 = &temp2;
6626 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6627 {
6628 if (!wxPyCheckForApp()) SWIG_fail;
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 wxDisplaySize(arg1,arg2);
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 resultobj = SWIG_Py_Void();
6635 if (SWIG_IsTmpObj(res1)) {
6636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6637 } else {
6638 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6640 }
6641 if (SWIG_IsTmpObj(res2)) {
6642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6643 } else {
6644 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6646 }
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6654 PyObject *resultobj = 0;
6655 wxSize result;
6656
6657 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6658 {
6659 if (!wxPyCheckForApp()) SWIG_fail;
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = wxGetDisplaySize();
6662 wxPyEndAllowThreads(__tstate);
6663 if (PyErr_Occurred()) SWIG_fail;
6664 }
6665 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6666 return resultobj;
6667 fail:
6668 return NULL;
6669 }
6670
6671
6672 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6673 PyObject *resultobj = 0;
6674 int *arg1 = (int *) 0 ;
6675 int *arg2 = (int *) 0 ;
6676 int temp1 ;
6677 int res1 = SWIG_TMPOBJ ;
6678 int temp2 ;
6679 int res2 = SWIG_TMPOBJ ;
6680
6681 arg1 = &temp1;
6682 arg2 = &temp2;
6683 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6684 {
6685 if (!wxPyCheckForApp()) SWIG_fail;
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 wxDisplaySizeMM(arg1,arg2);
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_Py_Void();
6692 if (SWIG_IsTmpObj(res1)) {
6693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6694 } else {
6695 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6697 }
6698 if (SWIG_IsTmpObj(res2)) {
6699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6700 } else {
6701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6703 }
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6711 PyObject *resultobj = 0;
6712 wxSize result;
6713
6714 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6715 {
6716 if (!wxPyCheckForApp()) SWIG_fail;
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = wxGetDisplaySizeMM();
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 int *arg1 = (int *) 0 ;
6732 int *arg2 = (int *) 0 ;
6733 int *arg3 = (int *) 0 ;
6734 int *arg4 = (int *) 0 ;
6735 int temp1 ;
6736 int res1 = SWIG_TMPOBJ ;
6737 int temp2 ;
6738 int res2 = SWIG_TMPOBJ ;
6739 int temp3 ;
6740 int res3 = SWIG_TMPOBJ ;
6741 int temp4 ;
6742 int res4 = SWIG_TMPOBJ ;
6743
6744 arg1 = &temp1;
6745 arg2 = &temp2;
6746 arg3 = &temp3;
6747 arg4 = &temp4;
6748 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6749 {
6750 if (!wxPyCheckForApp()) SWIG_fail;
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 if (SWIG_IsTmpObj(res1)) {
6758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6759 } else {
6760 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6762 }
6763 if (SWIG_IsTmpObj(res2)) {
6764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6765 } else {
6766 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6768 }
6769 if (SWIG_IsTmpObj(res3)) {
6770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6771 } else {
6772 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6774 }
6775 if (SWIG_IsTmpObj(res4)) {
6776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6777 } else {
6778 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 PyObject *resultobj = 0;
6789 wxRect result;
6790
6791 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = wxGetClientDisplayRect();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = 0;
6808 wxCursor *arg1 = 0 ;
6809 void *argp1 = 0 ;
6810 int res1 = 0 ;
6811 PyObject * obj0 = 0 ;
6812 char * kwnames[] = {
6813 (char *) "cursor", NULL
6814 };
6815
6816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6817 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6820 }
6821 if (!argp1) {
6822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6823 }
6824 arg1 = reinterpret_cast< wxCursor * >(argp1);
6825 {
6826 if (!wxPyCheckForApp()) SWIG_fail;
6827 PyThreadState* __tstate = wxPyBeginAllowThreads();
6828 wxSetCursor(*arg1);
6829 wxPyEndAllowThreads(__tstate);
6830 if (PyErr_Occurred()) SWIG_fail;
6831 }
6832 resultobj = SWIG_Py_Void();
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6840 PyObject *resultobj = 0;
6841 void *result = 0 ;
6842
6843 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6844 {
6845 if (!wxPyCheckForApp()) SWIG_fail;
6846 PyThreadState* __tstate = wxPyBeginAllowThreads();
6847 result = (void *)wxGetXDisplay();
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj = 0;
6860 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 PyObject * obj0 = 0 ;
6864 char * kwnames[] = {
6865 (char *) "cursor", NULL
6866 };
6867
6868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6869 if (obj0) {
6870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6873 }
6874 arg1 = reinterpret_cast< wxCursor * >(argp1);
6875 }
6876 {
6877 if (!wxPyCheckForApp()) SWIG_fail;
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 wxBeginBusyCursor(arg1);
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 resultobj = SWIG_Py_Void();
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6891 PyObject *resultobj = 0;
6892 wxPoint result;
6893
6894 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6895 {
6896 if (!wxPyCheckForApp()) SWIG_fail;
6897 PyThreadState* __tstate = wxPyBeginAllowThreads();
6898 result = wxGetMousePosition();
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6910 PyObject *resultobj = 0;
6911 wxWindow *result = 0 ;
6912
6913 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6914 {
6915 if (!wxPyCheckForApp()) SWIG_fail;
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (wxWindow *)FindWindowAtPointer();
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = wxPyMake_wxObject(result, 0);
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6931 PyObject *resultobj = 0;
6932 wxWindow *result = 0 ;
6933
6934 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6935 {
6936 if (!wxPyCheckForApp()) SWIG_fail;
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 result = (wxWindow *)wxGetActiveWindow();
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 {
6943 resultobj = wxPyMake_wxObject(result, 0);
6944 }
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj = 0;
6953 wxPoint *arg1 = 0 ;
6954 wxWindow *result = 0 ;
6955 wxPoint temp1 ;
6956 PyObject * obj0 = 0 ;
6957 char * kwnames[] = {
6958 (char *) "pt", NULL
6959 };
6960
6961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6962 {
6963 arg1 = &temp1;
6964 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6965 }
6966 {
6967 if (!wxPyCheckForApp()) SWIG_fail;
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 {
6974 resultobj = wxPyMake_wxObject(result, 0);
6975 }
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj = 0;
6984 wxPoint *arg1 = 0 ;
6985 wxWindow *result = 0 ;
6986 wxPoint temp1 ;
6987 PyObject * obj0 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "pt", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6993 {
6994 arg1 = &temp1;
6995 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6996 }
6997 {
6998 if (!wxPyCheckForApp()) SWIG_fail;
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 {
7005 resultobj = wxPyMake_wxObject(result, 0);
7006 }
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = 0;
7015 wxWindow *arg1 = (wxWindow *) 0 ;
7016 wxWindow *result = 0 ;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 PyObject * obj0 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "win", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7028 }
7029 arg1 = reinterpret_cast< wxWindow * >(argp1);
7030 {
7031 if (!wxPyCheckForApp()) SWIG_fail;
7032 PyThreadState* __tstate = wxPyBeginAllowThreads();
7033 result = (wxWindow *)wxGetTopLevelParent(arg1);
7034 wxPyEndAllowThreads(__tstate);
7035 if (PyErr_Occurred()) SWIG_fail;
7036 }
7037 {
7038 resultobj = wxPyMake_wxObject(result, 0);
7039 }
7040 return resultobj;
7041 fail:
7042 return NULL;
7043 }
7044
7045
7046 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7047 PyObject *resultobj = 0;
7048 wxString *arg1 = 0 ;
7049 bool result;
7050 bool temp1 = false ;
7051 PyObject * obj0 = 0 ;
7052 char * kwnames[] = {
7053 (char *) "url", NULL
7054 };
7055
7056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7057 {
7058 arg1 = wxString_in_helper(obj0);
7059 if (arg1 == NULL) SWIG_fail;
7060 temp1 = true;
7061 }
7062 {
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 {
7069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7070 }
7071 {
7072 if (temp1)
7073 delete arg1;
7074 }
7075 return resultobj;
7076 fail:
7077 {
7078 if (temp1)
7079 delete arg1;
7080 }
7081 return NULL;
7082 }
7083
7084
7085 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7086 PyObject *resultobj = 0;
7087 wxKeyCode arg1 ;
7088 bool result;
7089 int val1 ;
7090 int ecode1 = 0 ;
7091 PyObject * obj0 = 0 ;
7092 char * kwnames[] = {
7093 (char *) "key", NULL
7094 };
7095
7096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7097 ecode1 = SWIG_AsVal_int(obj0, &val1);
7098 if (!SWIG_IsOK(ecode1)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7100 }
7101 arg1 = static_cast< wxKeyCode >(val1);
7102 {
7103 if (!wxPyCheckForApp()) SWIG_fail;
7104 PyThreadState* __tstate = wxPyBeginAllowThreads();
7105 result = (bool)wxGetKeyState(arg1);
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7119 PyObject *resultobj = 0;
7120 wxMouseState *result = 0 ;
7121
7122 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (wxMouseState *)new wxMouseState();
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxMouseState *arg1 = (wxMouseState *) 0 ;
7139 void *argp1 = 0 ;
7140 int res1 = 0 ;
7141 PyObject *swig_obj[1] ;
7142
7143 if (!args) SWIG_fail;
7144 swig_obj[0] = args;
7145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7146 if (!SWIG_IsOK(res1)) {
7147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7148 }
7149 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7150 {
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 delete arg1;
7153
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7165 PyObject *resultobj = 0;
7166 wxMouseState *arg1 = (wxMouseState *) 0 ;
7167 int result;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 PyObject *swig_obj[1] ;
7171
7172 if (!args) SWIG_fail;
7173 swig_obj[0] = args;
7174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7175 if (!SWIG_IsOK(res1)) {
7176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7177 }
7178 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 result = (int)(arg1)->GetX();
7182 wxPyEndAllowThreads(__tstate);
7183 if (PyErr_Occurred()) SWIG_fail;
7184 }
7185 resultobj = SWIG_From_int(static_cast< int >(result));
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7193 PyObject *resultobj = 0;
7194 wxMouseState *arg1 = (wxMouseState *) 0 ;
7195 int result;
7196 void *argp1 = 0 ;
7197 int res1 = 0 ;
7198 PyObject *swig_obj[1] ;
7199
7200 if (!args) SWIG_fail;
7201 swig_obj[0] = args;
7202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7203 if (!SWIG_IsOK(res1)) {
7204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7205 }
7206 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 result = (int)(arg1)->GetY();
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_From_int(static_cast< int >(result));
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7221 PyObject *resultobj = 0;
7222 wxMouseState *arg1 = (wxMouseState *) 0 ;
7223 bool result;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 PyObject *swig_obj[1] ;
7227
7228 if (!args) SWIG_fail;
7229 swig_obj[0] = args;
7230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7231 if (!SWIG_IsOK(res1)) {
7232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7233 }
7234 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7235 {
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 result = (bool)(arg1)->LeftDown();
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 {
7242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7243 }
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 PyObject *resultobj = 0;
7252 wxMouseState *arg1 = (wxMouseState *) 0 ;
7253 bool result;
7254 void *argp1 = 0 ;
7255 int res1 = 0 ;
7256 PyObject *swig_obj[1] ;
7257
7258 if (!args) SWIG_fail;
7259 swig_obj[0] = args;
7260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7261 if (!SWIG_IsOK(res1)) {
7262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7263 }
7264 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 result = (bool)(arg1)->MiddleDown();
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 {
7272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7273 }
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7281 PyObject *resultobj = 0;
7282 wxMouseState *arg1 = (wxMouseState *) 0 ;
7283 bool result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 PyObject *swig_obj[1] ;
7287
7288 if (!args) SWIG_fail;
7289 swig_obj[0] = args;
7290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7291 if (!SWIG_IsOK(res1)) {
7292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7293 }
7294 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 result = (bool)(arg1)->RightDown();
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 {
7302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7303 }
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7311 PyObject *resultobj = 0;
7312 wxMouseState *arg1 = (wxMouseState *) 0 ;
7313 bool result;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 PyObject *swig_obj[1] ;
7317
7318 if (!args) SWIG_fail;
7319 swig_obj[0] = args;
7320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7323 }
7324 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (bool)(arg1)->ControlDown();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7341 PyObject *resultobj = 0;
7342 wxMouseState *arg1 = (wxMouseState *) 0 ;
7343 bool result;
7344 void *argp1 = 0 ;
7345 int res1 = 0 ;
7346 PyObject *swig_obj[1] ;
7347
7348 if (!args) SWIG_fail;
7349 swig_obj[0] = args;
7350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7353 }
7354 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (bool)(arg1)->ShiftDown();
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *resultobj = 0;
7372 wxMouseState *arg1 = (wxMouseState *) 0 ;
7373 bool result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 PyObject *swig_obj[1] ;
7377
7378 if (!args) SWIG_fail;
7379 swig_obj[0] = args;
7380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7383 }
7384 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (bool)(arg1)->AltDown();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 {
7392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401 PyObject *resultobj = 0;
7402 wxMouseState *arg1 = (wxMouseState *) 0 ;
7403 bool result;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 PyObject *swig_obj[1] ;
7407
7408 if (!args) SWIG_fail;
7409 swig_obj[0] = args;
7410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7411 if (!SWIG_IsOK(res1)) {
7412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7413 }
7414 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 result = (bool)(arg1)->MetaDown();
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 {
7422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7423 }
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7431 PyObject *resultobj = 0;
7432 wxMouseState *arg1 = (wxMouseState *) 0 ;
7433 bool result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 PyObject *swig_obj[1] ;
7437
7438 if (!args) SWIG_fail;
7439 swig_obj[0] = args;
7440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7443 }
7444 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (bool)(arg1)->CmdDown();
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = 0;
7462 wxMouseState *arg1 = (wxMouseState *) 0 ;
7463 int arg2 ;
7464 void *argp1 = 0 ;
7465 int res1 = 0 ;
7466 int val2 ;
7467 int ecode2 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "x", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7478 }
7479 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7480 ecode2 = SWIG_AsVal_int(obj1, &val2);
7481 if (!SWIG_IsOK(ecode2)) {
7482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7483 }
7484 arg2 = static_cast< int >(val2);
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 (arg1)->SetX(arg2);
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 resultobj = SWIG_Py_Void();
7492 return resultobj;
7493 fail:
7494 return NULL;
7495 }
7496
7497
7498 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7499 PyObject *resultobj = 0;
7500 wxMouseState *arg1 = (wxMouseState *) 0 ;
7501 int arg2 ;
7502 void *argp1 = 0 ;
7503 int res1 = 0 ;
7504 int val2 ;
7505 int ecode2 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "y", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7516 }
7517 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7518 ecode2 = SWIG_AsVal_int(obj1, &val2);
7519 if (!SWIG_IsOK(ecode2)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7521 }
7522 arg2 = static_cast< int >(val2);
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 (arg1)->SetY(arg2);
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 resultobj = SWIG_Py_Void();
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj = 0;
7538 wxMouseState *arg1 = (wxMouseState *) 0 ;
7539 bool arg2 ;
7540 void *argp1 = 0 ;
7541 int res1 = 0 ;
7542 bool val2 ;
7543 int ecode2 = 0 ;
7544 PyObject * obj0 = 0 ;
7545 PyObject * obj1 = 0 ;
7546 char * kwnames[] = {
7547 (char *) "self",(char *) "down", NULL
7548 };
7549
7550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7554 }
7555 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7557 if (!SWIG_IsOK(ecode2)) {
7558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7559 }
7560 arg2 = static_cast< bool >(val2);
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 (arg1)->SetLeftDown(arg2);
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_Py_Void();
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxMouseState *arg1 = (wxMouseState *) 0 ;
7577 bool arg2 ;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 bool val2 ;
7581 int ecode2 = 0 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "down", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7592 }
7593 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7594 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7595 if (!SWIG_IsOK(ecode2)) {
7596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7597 }
7598 arg2 = static_cast< bool >(val2);
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 (arg1)->SetMiddleDown(arg2);
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 resultobj = SWIG_Py_Void();
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = 0;
7614 wxMouseState *arg1 = (wxMouseState *) 0 ;
7615 bool arg2 ;
7616 void *argp1 = 0 ;
7617 int res1 = 0 ;
7618 bool val2 ;
7619 int ecode2 = 0 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "down", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7630 }
7631 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7632 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7633 if (!SWIG_IsOK(ecode2)) {
7634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7635 }
7636 arg2 = static_cast< bool >(val2);
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 (arg1)->SetRightDown(arg2);
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 resultobj = SWIG_Py_Void();
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj = 0;
7652 wxMouseState *arg1 = (wxMouseState *) 0 ;
7653 bool arg2 ;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 bool val2 ;
7657 int ecode2 = 0 ;
7658 PyObject * obj0 = 0 ;
7659 PyObject * obj1 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "down", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7668 }
7669 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7671 if (!SWIG_IsOK(ecode2)) {
7672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7673 }
7674 arg2 = static_cast< bool >(val2);
7675 {
7676 PyThreadState* __tstate = wxPyBeginAllowThreads();
7677 (arg1)->SetControlDown(arg2);
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 resultobj = SWIG_Py_Void();
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj = 0;
7690 wxMouseState *arg1 = (wxMouseState *) 0 ;
7691 bool arg2 ;
7692 void *argp1 = 0 ;
7693 int res1 = 0 ;
7694 bool val2 ;
7695 int ecode2 = 0 ;
7696 PyObject * obj0 = 0 ;
7697 PyObject * obj1 = 0 ;
7698 char * kwnames[] = {
7699 (char *) "self",(char *) "down", NULL
7700 };
7701
7702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7704 if (!SWIG_IsOK(res1)) {
7705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7706 }
7707 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7709 if (!SWIG_IsOK(ecode2)) {
7710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7711 }
7712 arg2 = static_cast< bool >(val2);
7713 {
7714 PyThreadState* __tstate = wxPyBeginAllowThreads();
7715 (arg1)->SetShiftDown(arg2);
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 resultobj = SWIG_Py_Void();
7720 return resultobj;
7721 fail:
7722 return NULL;
7723 }
7724
7725
7726 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7727 PyObject *resultobj = 0;
7728 wxMouseState *arg1 = (wxMouseState *) 0 ;
7729 bool arg2 ;
7730 void *argp1 = 0 ;
7731 int res1 = 0 ;
7732 bool val2 ;
7733 int ecode2 = 0 ;
7734 PyObject * obj0 = 0 ;
7735 PyObject * obj1 = 0 ;
7736 char * kwnames[] = {
7737 (char *) "self",(char *) "down", NULL
7738 };
7739
7740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7742 if (!SWIG_IsOK(res1)) {
7743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7744 }
7745 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7746 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7747 if (!SWIG_IsOK(ecode2)) {
7748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7749 }
7750 arg2 = static_cast< bool >(val2);
7751 {
7752 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753 (arg1)->SetAltDown(arg2);
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 resultobj = SWIG_Py_Void();
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxMouseState *arg1 = (wxMouseState *) 0 ;
7767 bool arg2 ;
7768 void *argp1 = 0 ;
7769 int res1 = 0 ;
7770 bool val2 ;
7771 int ecode2 = 0 ;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 char * kwnames[] = {
7775 (char *) "self",(char *) "down", NULL
7776 };
7777
7778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7780 if (!SWIG_IsOK(res1)) {
7781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7782 }
7783 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7784 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7785 if (!SWIG_IsOK(ecode2)) {
7786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7787 }
7788 arg2 = static_cast< bool >(val2);
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 (arg1)->SetMetaDown(arg2);
7792 wxPyEndAllowThreads(__tstate);
7793 if (PyErr_Occurred()) SWIG_fail;
7794 }
7795 resultobj = SWIG_Py_Void();
7796 return resultobj;
7797 fail:
7798 return NULL;
7799 }
7800
7801
7802 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7803 PyObject *obj;
7804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7805 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7806 return SWIG_Py_Void();
7807 }
7808
7809 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 return SWIG_Python_InitShadowInstance(args);
7811 }
7812
7813 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7814 PyObject *resultobj = 0;
7815 wxMouseState result;
7816
7817 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = wxGetMouseState();
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7825 return resultobj;
7826 fail:
7827 return NULL;
7828 }
7829
7830
7831 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832 PyObject *resultobj = 0;
7833
7834 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7835 {
7836 if (!wxPyCheckForApp()) SWIG_fail;
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 wxWakeUpMainThread();
7839 wxPyEndAllowThreads(__tstate);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 resultobj = SWIG_Py_Void();
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7850 PyObject *resultobj = 0;
7851
7852 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7853 {
7854 if (!wxPyCheckForApp()) SWIG_fail;
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 wxMutexGuiEnter();
7857 wxPyEndAllowThreads(__tstate);
7858 if (PyErr_Occurred()) SWIG_fail;
7859 }
7860 resultobj = SWIG_Py_Void();
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869
7870 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7871 {
7872 if (!wxPyCheckForApp()) SWIG_fail;
7873 PyThreadState* __tstate = wxPyBeginAllowThreads();
7874 wxMutexGuiLeave();
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 resultobj = SWIG_Py_Void();
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7886 PyObject *resultobj = 0;
7887 wxMutexGuiLocker *result = 0 ;
7888
7889 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7890 {
7891 if (!wxPyCheckForApp()) SWIG_fail;
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 PyObject *resultobj = 0;
7906 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7907 void *argp1 = 0 ;
7908 int res1 = 0 ;
7909 PyObject *swig_obj[1] ;
7910
7911 if (!args) SWIG_fail;
7912 swig_obj[0] = args;
7913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7914 if (!SWIG_IsOK(res1)) {
7915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7916 }
7917 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 delete arg1;
7921
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_Py_Void();
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933 PyObject *obj;
7934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7935 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7936 return SWIG_Py_Void();
7937 }
7938
7939 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7940 return SWIG_Python_InitShadowInstance(args);
7941 }
7942
7943 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 PyObject *resultobj = 0;
7945 bool result;
7946
7947 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (bool)wxThread_IsMain();
7951 wxPyEndAllowThreads(__tstate);
7952 if (PyErr_Occurred()) SWIG_fail;
7953 }
7954 {
7955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7956 }
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7964 PyObject *resultobj = 0;
7965 wxString *arg1 = 0 ;
7966 wxToolTip *result = 0 ;
7967 bool temp1 = false ;
7968 PyObject * obj0 = 0 ;
7969 char * kwnames[] = {
7970 (char *) "tip", NULL
7971 };
7972
7973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7974 {
7975 arg1 = wxString_in_helper(obj0);
7976 if (arg1 == NULL) SWIG_fail;
7977 temp1 = true;
7978 }
7979 {
7980 if (!wxPyCheckForApp()) SWIG_fail;
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7987 {
7988 if (temp1)
7989 delete arg1;
7990 }
7991 return resultobj;
7992 fail:
7993 {
7994 if (temp1)
7995 delete arg1;
7996 }
7997 return NULL;
7998 }
7999
8000
8001 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8002 PyObject *resultobj = 0;
8003 wxToolTip *arg1 = (wxToolTip *) 0 ;
8004 void *argp1 = 0 ;
8005 int res1 = 0 ;
8006 PyObject *swig_obj[1] ;
8007
8008 if (!args) SWIG_fail;
8009 swig_obj[0] = args;
8010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8011 if (!SWIG_IsOK(res1)) {
8012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8013 }
8014 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 delete arg1;
8018
8019 wxPyEndAllowThreads(__tstate);
8020 if (PyErr_Occurred()) SWIG_fail;
8021 }
8022 resultobj = SWIG_Py_Void();
8023 return resultobj;
8024 fail:
8025 return NULL;
8026 }
8027
8028
8029 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8030 PyObject *resultobj = 0;
8031 wxToolTip *arg1 = (wxToolTip *) 0 ;
8032 wxString *arg2 = 0 ;
8033 void *argp1 = 0 ;
8034 int res1 = 0 ;
8035 bool temp2 = false ;
8036 PyObject * obj0 = 0 ;
8037 PyObject * obj1 = 0 ;
8038 char * kwnames[] = {
8039 (char *) "self",(char *) "tip", NULL
8040 };
8041
8042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8044 if (!SWIG_IsOK(res1)) {
8045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8046 }
8047 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8048 {
8049 arg2 = wxString_in_helper(obj1);
8050 if (arg2 == NULL) SWIG_fail;
8051 temp2 = true;
8052 }
8053 {
8054 PyThreadState* __tstate = wxPyBeginAllowThreads();
8055 (arg1)->SetTip((wxString const &)*arg2);
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 resultobj = SWIG_Py_Void();
8060 {
8061 if (temp2)
8062 delete arg2;
8063 }
8064 return resultobj;
8065 fail:
8066 {
8067 if (temp2)
8068 delete arg2;
8069 }
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8075 PyObject *resultobj = 0;
8076 wxToolTip *arg1 = (wxToolTip *) 0 ;
8077 wxString result;
8078 void *argp1 = 0 ;
8079 int res1 = 0 ;
8080 PyObject *swig_obj[1] ;
8081
8082 if (!args) SWIG_fail;
8083 swig_obj[0] = args;
8084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8085 if (!SWIG_IsOK(res1)) {
8086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8087 }
8088 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8089 {
8090 PyThreadState* __tstate = wxPyBeginAllowThreads();
8091 result = (arg1)->GetTip();
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 #if wxUSE_UNICODE
8097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8098 #else
8099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8100 #endif
8101 }
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 wxToolTip *arg1 = (wxToolTip *) 0 ;
8111 wxWindow *result = 0 ;
8112 void *argp1 = 0 ;
8113 int res1 = 0 ;
8114 PyObject *swig_obj[1] ;
8115
8116 if (!args) SWIG_fail;
8117 swig_obj[0] = args;
8118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8119 if (!SWIG_IsOK(res1)) {
8120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8121 }
8122 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8123 {
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 result = (wxWindow *)(arg1)->GetWindow();
8126 wxPyEndAllowThreads(__tstate);
8127 if (PyErr_Occurred()) SWIG_fail;
8128 }
8129 {
8130 resultobj = wxPyMake_wxObject(result, 0);
8131 }
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8139 PyObject *resultobj = 0;
8140 bool arg1 ;
8141 bool val1 ;
8142 int ecode1 = 0 ;
8143 PyObject * obj0 = 0 ;
8144 char * kwnames[] = {
8145 (char *) "flag", NULL
8146 };
8147
8148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8149 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8150 if (!SWIG_IsOK(ecode1)) {
8151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8152 }
8153 arg1 = static_cast< bool >(val1);
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 wxToolTip::Enable(arg1);
8157 wxPyEndAllowThreads(__tstate);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 resultobj = SWIG_Py_Void();
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj = 0;
8169 long arg1 ;
8170 long val1 ;
8171 int ecode1 = 0 ;
8172 PyObject * obj0 = 0 ;
8173 char * kwnames[] = {
8174 (char *) "milliseconds", NULL
8175 };
8176
8177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8178 ecode1 = SWIG_AsVal_long(obj0, &val1);
8179 if (!SWIG_IsOK(ecode1)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8181 }
8182 arg1 = static_cast< long >(val1);
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 wxToolTip::SetDelay(arg1);
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_Py_Void();
8190 return resultobj;
8191 fail:
8192 return NULL;
8193 }
8194
8195
8196 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8197 PyObject *obj;
8198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8199 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8200 return SWIG_Py_Void();
8201 }
8202
8203 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 return SWIG_Python_InitShadowInstance(args);
8205 }
8206
8207 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = 0;
8209 wxWindow *arg1 = (wxWindow *) 0 ;
8210 wxSize *arg2 = 0 ;
8211 wxCaret *result = 0 ;
8212 void *argp1 = 0 ;
8213 int res1 = 0 ;
8214 wxSize temp2 ;
8215 PyObject * obj0 = 0 ;
8216 PyObject * obj1 = 0 ;
8217 char * kwnames[] = {
8218 (char *) "window",(char *) "size", NULL
8219 };
8220
8221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8223 if (!SWIG_IsOK(res1)) {
8224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8225 }
8226 arg1 = reinterpret_cast< wxWindow * >(argp1);
8227 {
8228 arg2 = &temp2;
8229 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8230 }
8231 {
8232 if (!wxPyCheckForApp()) SWIG_fail;
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8239 return resultobj;
8240 fail:
8241 return NULL;
8242 }
8243
8244
8245 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8246 PyObject *resultobj = 0;
8247 wxCaret *arg1 = (wxCaret *) 0 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 PyObject *swig_obj[1] ;
8251
8252 if (!args) SWIG_fail;
8253 swig_obj[0] = args;
8254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8257 }
8258 arg1 = reinterpret_cast< wxCaret * >(argp1);
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 delete arg1;
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 resultobj = SWIG_Py_Void();
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 PyObject *resultobj = 0;
8275 wxCaret *arg1 = (wxCaret *) 0 ;
8276 void *argp1 = 0 ;
8277 int res1 = 0 ;
8278 PyObject *swig_obj[1] ;
8279
8280 if (!args) SWIG_fail;
8281 swig_obj[0] = args;
8282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8283 if (!SWIG_IsOK(res1)) {
8284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8285 }
8286 arg1 = reinterpret_cast< wxCaret * >(argp1);
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 wxCaret_Destroy(arg1);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_Py_Void();
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxCaret *arg1 = (wxCaret *) 0 ;
8303 bool result;
8304 void *argp1 = 0 ;
8305 int res1 = 0 ;
8306 PyObject *swig_obj[1] ;
8307
8308 if (!args) SWIG_fail;
8309 swig_obj[0] = args;
8310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8311 if (!SWIG_IsOK(res1)) {
8312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8313 }
8314 arg1 = reinterpret_cast< wxCaret * >(argp1);
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (bool)(arg1)->IsOk();
8318 wxPyEndAllowThreads(__tstate);
8319 if (PyErr_Occurred()) SWIG_fail;
8320 }
8321 {
8322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8331 PyObject *resultobj = 0;
8332 wxCaret *arg1 = (wxCaret *) 0 ;
8333 bool result;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 PyObject *swig_obj[1] ;
8337
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8343 }
8344 arg1 = reinterpret_cast< wxCaret * >(argp1);
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 result = (bool)(arg1)->IsVisible();
8348 wxPyEndAllowThreads(__tstate);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 {
8352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8353 }
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8361 PyObject *resultobj = 0;
8362 wxCaret *arg1 = (wxCaret *) 0 ;
8363 wxPoint result;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 PyObject *swig_obj[1] ;
8367
8368 if (!args) SWIG_fail;
8369 swig_obj[0] = args;
8370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8371 if (!SWIG_IsOK(res1)) {
8372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8373 }
8374 arg1 = reinterpret_cast< wxCaret * >(argp1);
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 result = (arg1)->GetPosition();
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8382 return resultobj;
8383 fail:
8384 return NULL;
8385 }
8386
8387
8388 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8389 PyObject *resultobj = 0;
8390 wxCaret *arg1 = (wxCaret *) 0 ;
8391 int *arg2 = (int *) 0 ;
8392 int *arg3 = (int *) 0 ;
8393 void *argp1 = 0 ;
8394 int res1 = 0 ;
8395 int temp2 ;
8396 int res2 = SWIG_TMPOBJ ;
8397 int temp3 ;
8398 int res3 = SWIG_TMPOBJ ;
8399 PyObject *swig_obj[1] ;
8400
8401 arg2 = &temp2;
8402 arg3 = &temp3;
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8408 }
8409 arg1 = reinterpret_cast< wxCaret * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 (arg1)->GetPosition(arg2,arg3);
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_Py_Void();
8417 if (SWIG_IsTmpObj(res2)) {
8418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8419 } else {
8420 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8422 }
8423 if (SWIG_IsTmpObj(res3)) {
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8425 } else {
8426 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8428 }
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436 PyObject *resultobj = 0;
8437 wxCaret *arg1 = (wxCaret *) 0 ;
8438 wxSize result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 PyObject *swig_obj[1] ;
8442
8443 if (!args) SWIG_fail;
8444 swig_obj[0] = args;
8445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8446 if (!SWIG_IsOK(res1)) {
8447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8448 }
8449 arg1 = reinterpret_cast< wxCaret * >(argp1);
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (arg1)->GetSize();
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8464 PyObject *resultobj = 0;
8465 wxCaret *arg1 = (wxCaret *) 0 ;
8466 int *arg2 = (int *) 0 ;
8467 int *arg3 = (int *) 0 ;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 int temp2 ;
8471 int res2 = SWIG_TMPOBJ ;
8472 int temp3 ;
8473 int res3 = SWIG_TMPOBJ ;
8474 PyObject *swig_obj[1] ;
8475
8476 arg2 = &temp2;
8477 arg3 = &temp3;
8478 if (!args) SWIG_fail;
8479 swig_obj[0] = args;
8480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8481 if (!SWIG_IsOK(res1)) {
8482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8483 }
8484 arg1 = reinterpret_cast< wxCaret * >(argp1);
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 (arg1)->GetSize(arg2,arg3);
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_Py_Void();
8492 if (SWIG_IsTmpObj(res2)) {
8493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8494 } else {
8495 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8497 }
8498 if (SWIG_IsTmpObj(res3)) {
8499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8500 } else {
8501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxCaret *arg1 = (wxCaret *) 0 ;
8513 wxWindow *result = 0 ;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8523 }
8524 arg1 = reinterpret_cast< wxCaret * >(argp1);
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (wxWindow *)(arg1)->GetWindow();
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = wxPyMake_wxObject(result, 0);
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxCaret *arg1 = (wxCaret *) 0 ;
8543 int arg2 ;
8544 int arg3 ;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 int val2 ;
8548 int ecode2 = 0 ;
8549 int val3 ;
8550 int ecode3 = 0 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 PyObject * obj2 = 0 ;
8554 char * kwnames[] = {
8555 (char *) "self",(char *) "x",(char *) "y", NULL
8556 };
8557
8558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8560 if (!SWIG_IsOK(res1)) {
8561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8562 }
8563 arg1 = reinterpret_cast< wxCaret * >(argp1);
8564 ecode2 = SWIG_AsVal_int(obj1, &val2);
8565 if (!SWIG_IsOK(ecode2)) {
8566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8567 }
8568 arg2 = static_cast< int >(val2);
8569 ecode3 = SWIG_AsVal_int(obj2, &val3);
8570 if (!SWIG_IsOK(ecode3)) {
8571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8572 }
8573 arg3 = static_cast< int >(val3);
8574 {
8575 PyThreadState* __tstate = wxPyBeginAllowThreads();
8576 (arg1)->Move(arg2,arg3);
8577 wxPyEndAllowThreads(__tstate);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 resultobj = SWIG_Py_Void();
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8588 PyObject *resultobj = 0;
8589 wxCaret *arg1 = (wxCaret *) 0 ;
8590 wxPoint *arg2 = 0 ;
8591 void *argp1 = 0 ;
8592 int res1 = 0 ;
8593 wxPoint temp2 ;
8594 PyObject * obj0 = 0 ;
8595 PyObject * obj1 = 0 ;
8596 char * kwnames[] = {
8597 (char *) "self",(char *) "pt", NULL
8598 };
8599
8600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8602 if (!SWIG_IsOK(res1)) {
8603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8604 }
8605 arg1 = reinterpret_cast< wxCaret * >(argp1);
8606 {
8607 arg2 = &temp2;
8608 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8609 }
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 (arg1)->Move((wxPoint const &)*arg2);
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 resultobj = SWIG_Py_Void();
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj = 0;
8625 wxCaret *arg1 = (wxCaret *) 0 ;
8626 int arg2 ;
8627 int arg3 ;
8628 void *argp1 = 0 ;
8629 int res1 = 0 ;
8630 int val2 ;
8631 int ecode2 = 0 ;
8632 int val3 ;
8633 int ecode3 = 0 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 PyObject * obj2 = 0 ;
8637 char * kwnames[] = {
8638 (char *) "self",(char *) "width",(char *) "height", NULL
8639 };
8640
8641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8645 }
8646 arg1 = reinterpret_cast< wxCaret * >(argp1);
8647 ecode2 = SWIG_AsVal_int(obj1, &val2);
8648 if (!SWIG_IsOK(ecode2)) {
8649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8650 }
8651 arg2 = static_cast< int >(val2);
8652 ecode3 = SWIG_AsVal_int(obj2, &val3);
8653 if (!SWIG_IsOK(ecode3)) {
8654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8655 }
8656 arg3 = static_cast< int >(val3);
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 (arg1)->SetSize(arg2,arg3);
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 resultobj = SWIG_Py_Void();
8664 return resultobj;
8665 fail:
8666 return NULL;
8667 }
8668
8669
8670 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8671 PyObject *resultobj = 0;
8672 wxCaret *arg1 = (wxCaret *) 0 ;
8673 wxSize *arg2 = 0 ;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 wxSize temp2 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 char * kwnames[] = {
8680 (char *) "self",(char *) "size", NULL
8681 };
8682
8683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8685 if (!SWIG_IsOK(res1)) {
8686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8687 }
8688 arg1 = reinterpret_cast< wxCaret * >(argp1);
8689 {
8690 arg2 = &temp2;
8691 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8692 }
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 (arg1)->SetSize((wxSize const &)*arg2);
8696 wxPyEndAllowThreads(__tstate);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 resultobj = SWIG_Py_Void();
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8707 PyObject *resultobj = 0;
8708 wxCaret *arg1 = (wxCaret *) 0 ;
8709 int arg2 = (int) true ;
8710 void *argp1 = 0 ;
8711 int res1 = 0 ;
8712 int val2 ;
8713 int ecode2 = 0 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char * kwnames[] = {
8717 (char *) "self",(char *) "show", NULL
8718 };
8719
8720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8724 }
8725 arg1 = reinterpret_cast< wxCaret * >(argp1);
8726 if (obj1) {
8727 ecode2 = SWIG_AsVal_int(obj1, &val2);
8728 if (!SWIG_IsOK(ecode2)) {
8729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8730 }
8731 arg2 = static_cast< int >(val2);
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 (arg1)->Show(arg2);
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 resultobj = SWIG_Py_Void();
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 void *argp1 = 0 ;
8750 int res1 = 0 ;
8751 PyObject *swig_obj[1] ;
8752
8753 if (!args) SWIG_fail;
8754 swig_obj[0] = args;
8755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8756 if (!SWIG_IsOK(res1)) {
8757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8758 }
8759 arg1 = reinterpret_cast< wxCaret * >(argp1);
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 (arg1)->Hide();
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 int result;
8776
8777 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8778 {
8779 PyThreadState* __tstate = wxPyBeginAllowThreads();
8780 result = (int)wxCaret::GetBlinkTime();
8781 wxPyEndAllowThreads(__tstate);
8782 if (PyErr_Occurred()) SWIG_fail;
8783 }
8784 resultobj = SWIG_From_int(static_cast< int >(result));
8785 return resultobj;
8786 fail:
8787 return NULL;
8788 }
8789
8790
8791 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj = 0;
8793 int arg1 ;
8794 int val1 ;
8795 int ecode1 = 0 ;
8796 PyObject * obj0 = 0 ;
8797 char * kwnames[] = {
8798 (char *) "milliseconds", NULL
8799 };
8800
8801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8802 ecode1 = SWIG_AsVal_int(obj0, &val1);
8803 if (!SWIG_IsOK(ecode1)) {
8804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8805 }
8806 arg1 = static_cast< int >(val1);
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 wxCaret::SetBlinkTime(arg1);
8810 wxPyEndAllowThreads(__tstate);
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 resultobj = SWIG_Py_Void();
8814 return resultobj;
8815 fail:
8816 return NULL;
8817 }
8818
8819
8820 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8821 PyObject *obj;
8822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8823 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8824 return SWIG_Py_Void();
8825 }
8826
8827 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8828 return SWIG_Python_InitShadowInstance(args);
8829 }
8830
8831 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8834 wxBusyCursor *result = 0 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 PyObject * obj0 = 0 ;
8838 char * kwnames[] = {
8839 (char *) "cursor", NULL
8840 };
8841
8842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8843 if (obj0) {
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCursor * >(argp1);
8849 }
8850 {
8851 if (!wxPyCheckForApp()) SWIG_fail;
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *resultobj = 0;
8866 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject *swig_obj[1] ;
8870
8871 if (!args) SWIG_fail;
8872 swig_obj[0] = args;
8873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8876 }
8877 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 delete arg1;
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893 PyObject *obj;
8894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8895 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8896 return SWIG_Py_Void();
8897 }
8898
8899 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 return SWIG_Python_InitShadowInstance(args);
8901 }
8902
8903 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8904 PyObject *resultobj = 0;
8905 wxWindow *arg1 = (wxWindow *) NULL ;
8906 wxWindowDisabler *result = 0 ;
8907 void *argp1 = 0 ;
8908 int res1 = 0 ;
8909 PyObject * obj0 = 0 ;
8910 char * kwnames[] = {
8911 (char *) "winToSkip", NULL
8912 };
8913
8914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8915 if (obj0) {
8916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8917 if (!SWIG_IsOK(res1)) {
8918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8919 }
8920 arg1 = reinterpret_cast< wxWindow * >(argp1);
8921 }
8922 {
8923 if (!wxPyCheckForApp()) SWIG_fail;
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8926 wxPyEndAllowThreads(__tstate);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8930 return resultobj;
8931 fail:
8932 return NULL;
8933 }
8934
8935
8936 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8937 PyObject *resultobj = 0;
8938 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8939 void *argp1 = 0 ;
8940 int res1 = 0 ;
8941 PyObject *swig_obj[1] ;
8942
8943 if (!args) SWIG_fail;
8944 swig_obj[0] = args;
8945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8948 }
8949 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8950 {
8951 PyThreadState* __tstate = wxPyBeginAllowThreads();
8952 delete arg1;
8953
8954 wxPyEndAllowThreads(__tstate);
8955 if (PyErr_Occurred()) SWIG_fail;
8956 }
8957 resultobj = SWIG_Py_Void();
8958 return resultobj;
8959 fail:
8960 return NULL;
8961 }
8962
8963
8964 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8965 PyObject *obj;
8966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8967 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8968 return SWIG_Py_Void();
8969 }
8970
8971 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8972 return SWIG_Python_InitShadowInstance(args);
8973 }
8974
8975 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8976 PyObject *resultobj = 0;
8977 wxString *arg1 = 0 ;
8978 wxBusyInfo *result = 0 ;
8979 bool temp1 = false ;
8980 PyObject * obj0 = 0 ;
8981 char * kwnames[] = {
8982 (char *) "message", NULL
8983 };
8984
8985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8986 {
8987 arg1 = wxString_in_helper(obj0);
8988 if (arg1 == NULL) SWIG_fail;
8989 temp1 = true;
8990 }
8991 {
8992 if (!wxPyCheckForApp()) SWIG_fail;
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8999 {
9000 if (temp1)
9001 delete arg1;
9002 }
9003 return resultobj;
9004 fail:
9005 {
9006 if (temp1)
9007 delete arg1;
9008 }
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9014 PyObject *resultobj = 0;
9015 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9016 void *argp1 = 0 ;
9017 int res1 = 0 ;
9018 PyObject *swig_obj[1] ;
9019
9020 if (!args) SWIG_fail;
9021 swig_obj[0] = args;
9022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9023 if (!SWIG_IsOK(res1)) {
9024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9025 }
9026 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 delete arg1;
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 resultobj = SWIG_Py_Void();
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 PyObject *obj;
9043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9044 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9045 return SWIG_Py_Void();
9046 }
9047
9048 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 return SWIG_Python_InitShadowInstance(args);
9050 }
9051
9052 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *resultobj = 0;
9054 wxStopWatch *result = 0 ;
9055
9056 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = (wxStopWatch *)new wxStopWatch();
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj = 0;
9072 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9073 long arg2 = (long) 0 ;
9074 void *argp1 = 0 ;
9075 int res1 = 0 ;
9076 long val2 ;
9077 int ecode2 = 0 ;
9078 PyObject * obj0 = 0 ;
9079 PyObject * obj1 = 0 ;
9080 char * kwnames[] = {
9081 (char *) "self",(char *) "t0", NULL
9082 };
9083
9084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9088 }
9089 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9090 if (obj1) {
9091 ecode2 = SWIG_AsVal_long(obj1, &val2);
9092 if (!SWIG_IsOK(ecode2)) {
9093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9094 }
9095 arg2 = static_cast< long >(val2);
9096 }
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 (arg1)->Start(arg2);
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_Py_Void();
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9111 PyObject *resultobj = 0;
9112 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject *swig_obj[1] ;
9116
9117 if (!args) SWIG_fail;
9118 swig_obj[0] = args;
9119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9120 if (!SWIG_IsOK(res1)) {
9121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9122 }
9123 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 (arg1)->Pause();
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_Py_Void();
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138 PyObject *resultobj = 0;
9139 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9140 void *argp1 = 0 ;
9141 int res1 = 0 ;
9142 PyObject *swig_obj[1] ;
9143
9144 if (!args) SWIG_fail;
9145 swig_obj[0] = args;
9146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9147 if (!SWIG_IsOK(res1)) {
9148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9149 }
9150 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 (arg1)->Resume();
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 resultobj = SWIG_Py_Void();
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9165 PyObject *resultobj = 0;
9166 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9167 long result;
9168 void *argp1 = 0 ;
9169 int res1 = 0 ;
9170 PyObject *swig_obj[1] ;
9171
9172 if (!args) SWIG_fail;
9173 swig_obj[0] = args;
9174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9175 if (!SWIG_IsOK(res1)) {
9176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9177 }
9178 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 result = (long)((wxStopWatch const *)arg1)->Time();
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 resultobj = SWIG_From_long(static_cast< long >(result));
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9193 PyObject *obj;
9194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9195 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9196 return SWIG_Py_Void();
9197 }
9198
9199 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 return SWIG_Python_InitShadowInstance(args);
9201 }
9202
9203 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9204 PyObject *resultobj = 0;
9205 int arg1 = (int) 9 ;
9206 int arg2 = (int) wxID_FILE1 ;
9207 wxFileHistory *result = 0 ;
9208 int val1 ;
9209 int ecode1 = 0 ;
9210 int val2 ;
9211 int ecode2 = 0 ;
9212 PyObject * obj0 = 0 ;
9213 PyObject * obj1 = 0 ;
9214 char * kwnames[] = {
9215 (char *) "maxFiles",(char *) "idBase", NULL
9216 };
9217
9218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9219 if (obj0) {
9220 ecode1 = SWIG_AsVal_int(obj0, &val1);
9221 if (!SWIG_IsOK(ecode1)) {
9222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9223 }
9224 arg1 = static_cast< int >(val1);
9225 }
9226 if (obj1) {
9227 ecode2 = SWIG_AsVal_int(obj1, &val2);
9228 if (!SWIG_IsOK(ecode2)) {
9229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9230 }
9231 arg2 = static_cast< int >(val2);
9232 }
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9247 PyObject *resultobj = 0;
9248 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9249 void *argp1 = 0 ;
9250 int res1 = 0 ;
9251 PyObject *swig_obj[1] ;
9252
9253 if (!args) SWIG_fail;
9254 swig_obj[0] = args;
9255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9256 if (!SWIG_IsOK(res1)) {
9257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9258 }
9259 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 delete arg1;
9263
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_Py_Void();
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj = 0;
9276 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9277 wxString *arg2 = 0 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 bool temp2 = false ;
9281 PyObject * obj0 = 0 ;
9282 PyObject * obj1 = 0 ;
9283 char * kwnames[] = {
9284 (char *) "self",(char *) "file", NULL
9285 };
9286
9287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9291 }
9292 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9293 {
9294 arg2 = wxString_in_helper(obj1);
9295 if (arg2 == NULL) SWIG_fail;
9296 temp2 = true;
9297 }
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 (arg1)->AddFileToHistory((wxString const &)*arg2);
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_Py_Void();
9305 {
9306 if (temp2)
9307 delete arg2;
9308 }
9309 return resultobj;
9310 fail:
9311 {
9312 if (temp2)
9313 delete arg2;
9314 }
9315 return NULL;
9316 }
9317
9318
9319 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9320 PyObject *resultobj = 0;
9321 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9322 int arg2 ;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 int val2 ;
9326 int ecode2 = 0 ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 char * kwnames[] = {
9330 (char *) "self",(char *) "i", NULL
9331 };
9332
9333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9337 }
9338 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9339 ecode2 = SWIG_AsVal_int(obj1, &val2);
9340 if (!SWIG_IsOK(ecode2)) {
9341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9342 }
9343 arg2 = static_cast< int >(val2);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 (arg1)->RemoveFileFromHistory(arg2);
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_Py_Void();
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9360 int result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9370 }
9371 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 resultobj = SWIG_From_int(static_cast< int >(result));
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9386 PyObject *resultobj = 0;
9387 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9388 wxMenu *arg2 = (wxMenu *) 0 ;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 void *argp2 = 0 ;
9392 int res2 = 0 ;
9393 PyObject * obj0 = 0 ;
9394 PyObject * obj1 = 0 ;
9395 char * kwnames[] = {
9396 (char *) "self",(char *) "menu", NULL
9397 };
9398
9399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9401 if (!SWIG_IsOK(res1)) {
9402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9403 }
9404 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9406 if (!SWIG_IsOK(res2)) {
9407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9408 }
9409 arg2 = reinterpret_cast< wxMenu * >(argp2);
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 (arg1)->UseMenu(arg2);
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 resultobj = SWIG_Py_Void();
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj = 0;
9425 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9426 wxMenu *arg2 = (wxMenu *) 0 ;
9427 void *argp1 = 0 ;
9428 int res1 = 0 ;
9429 void *argp2 = 0 ;
9430 int res2 = 0 ;
9431 PyObject * obj0 = 0 ;
9432 PyObject * obj1 = 0 ;
9433 char * kwnames[] = {
9434 (char *) "self",(char *) "menu", NULL
9435 };
9436
9437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9439 if (!SWIG_IsOK(res1)) {
9440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9441 }
9442 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9444 if (!SWIG_IsOK(res2)) {
9445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9446 }
9447 arg2 = reinterpret_cast< wxMenu * >(argp2);
9448 {
9449 PyThreadState* __tstate = wxPyBeginAllowThreads();
9450 (arg1)->RemoveMenu(arg2);
9451 wxPyEndAllowThreads(__tstate);
9452 if (PyErr_Occurred()) SWIG_fail;
9453 }
9454 resultobj = SWIG_Py_Void();
9455 return resultobj;
9456 fail:
9457 return NULL;
9458 }
9459
9460
9461 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9462 PyObject *resultobj = 0;
9463 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9464 wxConfigBase *arg2 = 0 ;
9465 void *argp1 = 0 ;
9466 int res1 = 0 ;
9467 void *argp2 = 0 ;
9468 int res2 = 0 ;
9469 PyObject * obj0 = 0 ;
9470 PyObject * obj1 = 0 ;
9471 char * kwnames[] = {
9472 (char *) "self",(char *) "config", NULL
9473 };
9474
9475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9477 if (!SWIG_IsOK(res1)) {
9478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9479 }
9480 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9482 if (!SWIG_IsOK(res2)) {
9483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9484 }
9485 if (!argp2) {
9486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9487 }
9488 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 (arg1)->Load(*arg2);
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 resultobj = SWIG_Py_Void();
9496 return resultobj;
9497 fail:
9498 return NULL;
9499 }
9500
9501
9502 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9503 PyObject *resultobj = 0;
9504 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9505 wxConfigBase *arg2 = 0 ;
9506 void *argp1 = 0 ;
9507 int res1 = 0 ;
9508 void *argp2 = 0 ;
9509 int res2 = 0 ;
9510 PyObject * obj0 = 0 ;
9511 PyObject * obj1 = 0 ;
9512 char * kwnames[] = {
9513 (char *) "self",(char *) "config", NULL
9514 };
9515
9516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9518 if (!SWIG_IsOK(res1)) {
9519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9520 }
9521 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9523 if (!SWIG_IsOK(res2)) {
9524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9525 }
9526 if (!argp2) {
9527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9528 }
9529 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 (arg1)->Save(*arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_Py_Void();
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9544 PyObject *resultobj = 0;
9545 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9546 void *argp1 = 0 ;
9547 int res1 = 0 ;
9548 PyObject *swig_obj[1] ;
9549
9550 if (!args) SWIG_fail;
9551 swig_obj[0] = args;
9552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9553 if (!SWIG_IsOK(res1)) {
9554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9555 }
9556 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9557 {
9558 PyThreadState* __tstate = wxPyBeginAllowThreads();
9559 (arg1)->AddFilesToMenu();
9560 wxPyEndAllowThreads(__tstate);
9561 if (PyErr_Occurred()) SWIG_fail;
9562 }
9563 resultobj = SWIG_Py_Void();
9564 return resultobj;
9565 fail:
9566 return NULL;
9567 }
9568
9569
9570 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9571 PyObject *resultobj = 0;
9572 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9573 wxMenu *arg2 = (wxMenu *) 0 ;
9574 void *argp1 = 0 ;
9575 int res1 = 0 ;
9576 void *argp2 = 0 ;
9577 int res2 = 0 ;
9578 PyObject * obj0 = 0 ;
9579 PyObject * obj1 = 0 ;
9580 char * kwnames[] = {
9581 (char *) "self",(char *) "menu", NULL
9582 };
9583
9584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9586 if (!SWIG_IsOK(res1)) {
9587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9588 }
9589 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9591 if (!SWIG_IsOK(res2)) {
9592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9593 }
9594 arg2 = reinterpret_cast< wxMenu * >(argp2);
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 (arg1)->AddFilesToMenu(arg2);
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_Py_Void();
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9609 PyObject *resultobj = 0;
9610 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9611 int arg2 ;
9612 wxString result;
9613 void *argp1 = 0 ;
9614 int res1 = 0 ;
9615 int val2 ;
9616 int ecode2 = 0 ;
9617 PyObject * obj0 = 0 ;
9618 PyObject * obj1 = 0 ;
9619 char * kwnames[] = {
9620 (char *) "self",(char *) "i", NULL
9621 };
9622
9623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9625 if (!SWIG_IsOK(res1)) {
9626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9627 }
9628 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9629 ecode2 = SWIG_AsVal_int(obj1, &val2);
9630 if (!SWIG_IsOK(ecode2)) {
9631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9632 }
9633 arg2 = static_cast< int >(val2);
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9637 wxPyEndAllowThreads(__tstate);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 {
9641 #if wxUSE_UNICODE
9642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9643 #else
9644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9645 #endif
9646 }
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9654 PyObject *resultobj = 0;
9655 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9656 int result;
9657 void *argp1 = 0 ;
9658 int res1 = 0 ;
9659 PyObject *swig_obj[1] ;
9660
9661 if (!args) SWIG_fail;
9662 swig_obj[0] = args;
9663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9664 if (!SWIG_IsOK(res1)) {
9665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9666 }
9667 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9668 {
9669 PyThreadState* __tstate = wxPyBeginAllowThreads();
9670 result = (int)((wxFileHistory const *)arg1)->GetCount();
9671 wxPyEndAllowThreads(__tstate);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 resultobj = SWIG_From_int(static_cast< int >(result));
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 PyObject *obj;
9683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9684 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9685 return SWIG_Py_Void();
9686 }
9687
9688 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9689 return SWIG_Python_InitShadowInstance(args);
9690 }
9691
9692 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9693 PyObject *resultobj = 0;
9694 wxString *arg1 = 0 ;
9695 wxString const &arg2_defvalue = wxPyEmptyString ;
9696 wxString *arg2 = (wxString *) &arg2_defvalue ;
9697 wxSingleInstanceChecker *result = 0 ;
9698 bool temp1 = false ;
9699 bool temp2 = false ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 char * kwnames[] = {
9703 (char *) "name",(char *) "path", NULL
9704 };
9705
9706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9707 {
9708 arg1 = wxString_in_helper(obj0);
9709 if (arg1 == NULL) SWIG_fail;
9710 temp1 = true;
9711 }
9712 if (obj1) {
9713 {
9714 arg2 = wxString_in_helper(obj1);
9715 if (arg2 == NULL) SWIG_fail;
9716 temp2 = true;
9717 }
9718 }
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9726 {
9727 if (temp1)
9728 delete arg1;
9729 }
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return resultobj;
9735 fail:
9736 {
9737 if (temp1)
9738 delete arg1;
9739 }
9740 {
9741 if (temp2)
9742 delete arg2;
9743 }
9744 return NULL;
9745 }
9746
9747
9748 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9749 PyObject *resultobj = 0;
9750 wxSingleInstanceChecker *result = 0 ;
9751
9752 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9753 {
9754 PyThreadState* __tstate = wxPyBeginAllowThreads();
9755 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9760 return resultobj;
9761 fail:
9762 return NULL;
9763 }
9764
9765
9766 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9767 PyObject *resultobj = 0;
9768 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9769 void *argp1 = 0 ;
9770 int res1 = 0 ;
9771 PyObject *swig_obj[1] ;
9772
9773 if (!args) SWIG_fail;
9774 swig_obj[0] = args;
9775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9776 if (!SWIG_IsOK(res1)) {
9777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9778 }
9779 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 delete arg1;
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 resultobj = SWIG_Py_Void();
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj = 0;
9796 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9797 wxString *arg2 = 0 ;
9798 wxString const &arg3_defvalue = wxPyEmptyString ;
9799 wxString *arg3 = (wxString *) &arg3_defvalue ;
9800 bool result;
9801 void *argp1 = 0 ;
9802 int res1 = 0 ;
9803 bool temp2 = false ;
9804 bool temp3 = false ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 char * kwnames[] = {
9809 (char *) "self",(char *) "name",(char *) "path", NULL
9810 };
9811
9812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9814 if (!SWIG_IsOK(res1)) {
9815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9816 }
9817 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9818 {
9819 arg2 = wxString_in_helper(obj1);
9820 if (arg2 == NULL) SWIG_fail;
9821 temp2 = true;
9822 }
9823 if (obj2) {
9824 {
9825 arg3 = wxString_in_helper(obj2);
9826 if (arg3 == NULL) SWIG_fail;
9827 temp3 = true;
9828 }
9829 }
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 {
9837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9838 }
9839 {
9840 if (temp2)
9841 delete arg2;
9842 }
9843 {
9844 if (temp3)
9845 delete arg3;
9846 }
9847 return resultobj;
9848 fail:
9849 {
9850 if (temp2)
9851 delete arg2;
9852 }
9853 {
9854 if (temp3)
9855 delete arg3;
9856 }
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 PyObject *resultobj = 0;
9863 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9864 bool result;
9865 void *argp1 = 0 ;
9866 int res1 = 0 ;
9867 PyObject *swig_obj[1] ;
9868
9869 if (!args) SWIG_fail;
9870 swig_obj[0] = args;
9871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9874 }
9875 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 {
9883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9884 }
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892 PyObject *obj;
9893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9894 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9895 return SWIG_Py_Void();
9896 }
9897
9898 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 return SWIG_Python_InitShadowInstance(args);
9900 }
9901
9902 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj = 0;
9904 wxWindow *arg1 = (wxWindow *) 0 ;
9905 wxDC *arg2 = 0 ;
9906 bool result;
9907 void *argp1 = 0 ;
9908 int res1 = 0 ;
9909 void *argp2 = 0 ;
9910 int res2 = 0 ;
9911 PyObject * obj0 = 0 ;
9912 PyObject * obj1 = 0 ;
9913 char * kwnames[] = {
9914 (char *) "window",(char *) "dc", NULL
9915 };
9916
9917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9919 if (!SWIG_IsOK(res1)) {
9920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9921 }
9922 arg1 = reinterpret_cast< wxWindow * >(argp1);
9923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9924 if (!SWIG_IsOK(res2)) {
9925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9926 }
9927 if (!argp2) {
9928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9929 }
9930 arg2 = reinterpret_cast< wxDC * >(argp2);
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9939 }
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *resultobj = 0;
9948 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9949 void *argp1 = 0 ;
9950 int res1 = 0 ;
9951 PyObject *swig_obj[1] ;
9952
9953 if (!args) SWIG_fail;
9954 swig_obj[0] = args;
9955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9956 if (!SWIG_IsOK(res1)) {
9957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9958 }
9959 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9960 {
9961 PyThreadState* __tstate = wxPyBeginAllowThreads();
9962 delete arg1;
9963
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_Py_Void();
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9975 PyObject *resultobj = 0;
9976 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9977 wxString result;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 PyObject *swig_obj[1] ;
9981
9982 if (!args) SWIG_fail;
9983 swig_obj[0] = args;
9984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9985 if (!SWIG_IsOK(res1)) {
9986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9987 }
9988 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (arg1)->GetTip();
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 {
9996 #if wxUSE_UNICODE
9997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9998 #else
9999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10000 #endif
10001 }
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10009 PyObject *resultobj = 0;
10010 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10011 size_t result;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 PyObject *swig_obj[1] ;
10015
10016 if (!args) SWIG_fail;
10017 swig_obj[0] = args;
10018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10021 }
10022 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 result = (size_t)(arg1)->GetCurrentTip();
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj = 0;
10038 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10039 wxString *arg2 = 0 ;
10040 wxString result;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 bool temp2 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 char * kwnames[] = {
10047 (char *) "self",(char *) "tip", NULL
10048 };
10049
10050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10054 }
10055 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10056 {
10057 arg2 = wxString_in_helper(obj1);
10058 if (arg2 == NULL) SWIG_fail;
10059 temp2 = true;
10060 }
10061 {
10062 PyThreadState* __tstate = wxPyBeginAllowThreads();
10063 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10064 wxPyEndAllowThreads(__tstate);
10065 if (PyErr_Occurred()) SWIG_fail;
10066 }
10067 {
10068 #if wxUSE_UNICODE
10069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10070 #else
10071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10072 #endif
10073 }
10074 {
10075 if (temp2)
10076 delete arg2;
10077 }
10078 return resultobj;
10079 fail:
10080 {
10081 if (temp2)
10082 delete arg2;
10083 }
10084 return NULL;
10085 }
10086
10087
10088 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10089 PyObject *obj;
10090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10091 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10092 return SWIG_Py_Void();
10093 }
10094
10095 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 size_t arg1 ;
10098 wxPyTipProvider *result = 0 ;
10099 size_t val1 ;
10100 int ecode1 = 0 ;
10101 PyObject * obj0 = 0 ;
10102 char * kwnames[] = {
10103 (char *) "currentTip", NULL
10104 };
10105
10106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10107 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10108 if (!SWIG_IsOK(ecode1)) {
10109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10110 }
10111 arg1 = static_cast< size_t >(val1);
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10126 PyObject *resultobj = 0;
10127 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10128 PyObject *arg2 = (PyObject *) 0 ;
10129 PyObject *arg3 = (PyObject *) 0 ;
10130 void *argp1 = 0 ;
10131 int res1 = 0 ;
10132 PyObject * obj0 = 0 ;
10133 PyObject * obj1 = 0 ;
10134 PyObject * obj2 = 0 ;
10135 char * kwnames[] = {
10136 (char *) "self",(char *) "self",(char *) "_class", NULL
10137 };
10138
10139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10141 if (!SWIG_IsOK(res1)) {
10142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10143 }
10144 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10145 arg2 = obj1;
10146 arg3 = obj2;
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 (arg1)->_setCallbackInfo(arg2,arg3);
10150 wxPyEndAllowThreads(__tstate);
10151 if (PyErr_Occurred()) SWIG_fail;
10152 }
10153 resultobj = SWIG_Py_Void();
10154 return resultobj;
10155 fail:
10156 return NULL;
10157 }
10158
10159
10160 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10161 PyObject *obj;
10162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10163 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10164 return SWIG_Py_Void();
10165 }
10166
10167 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10168 return SWIG_Python_InitShadowInstance(args);
10169 }
10170
10171 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj = 0;
10173 wxWindow *arg1 = (wxWindow *) 0 ;
10174 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10175 bool arg3 = (bool) true ;
10176 bool result;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 void *argp2 = 0 ;
10180 int res2 = 0 ;
10181 bool val3 ;
10182 int ecode3 = 0 ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 PyObject * obj2 = 0 ;
10186 char * kwnames[] = {
10187 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10188 };
10189
10190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10194 }
10195 arg1 = reinterpret_cast< wxWindow * >(argp1);
10196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10197 if (!SWIG_IsOK(res2)) {
10198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10199 }
10200 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10201 if (obj2) {
10202 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10203 if (!SWIG_IsOK(ecode3)) {
10204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10205 }
10206 arg3 = static_cast< bool >(val3);
10207 }
10208 {
10209 if (!wxPyCheckForApp()) SWIG_fail;
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 result = (bool)wxShowTip(arg1,arg2,arg3);
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 {
10216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10217 }
10218 return resultobj;
10219 fail:
10220 return NULL;
10221 }
10222
10223
10224 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10225 PyObject *resultobj = 0;
10226 wxString *arg1 = 0 ;
10227 size_t arg2 ;
10228 wxTipProvider *result = 0 ;
10229 bool temp1 = false ;
10230 size_t val2 ;
10231 int ecode2 = 0 ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 char * kwnames[] = {
10235 (char *) "filename",(char *) "currentTip", NULL
10236 };
10237
10238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10239 {
10240 arg1 = wxString_in_helper(obj0);
10241 if (arg1 == NULL) SWIG_fail;
10242 temp1 = true;
10243 }
10244 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10245 if (!SWIG_IsOK(ecode2)) {
10246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10247 }
10248 arg2 = static_cast< size_t >(val2);
10249 {
10250 if (!wxPyCheckForApp()) SWIG_fail;
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10257 {
10258 if (temp1)
10259 delete arg1;
10260 }
10261 return resultobj;
10262 fail:
10263 {
10264 if (temp1)
10265 delete arg1;
10266 }
10267 return NULL;
10268 }
10269
10270
10271 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10272 PyObject *resultobj = 0;
10273 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10274 int arg2 = (int) wxID_ANY ;
10275 wxPyTimer *result = 0 ;
10276 void *argp1 = 0 ;
10277 int res1 = 0 ;
10278 int val2 ;
10279 int ecode2 = 0 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 char * kwnames[] = {
10283 (char *) "owner",(char *) "id", NULL
10284 };
10285
10286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10287 if (obj0) {
10288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10289 if (!SWIG_IsOK(res1)) {
10290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10291 }
10292 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10293 }
10294 if (obj1) {
10295 ecode2 = SWIG_AsVal_int(obj1, &val2);
10296 if (!SWIG_IsOK(ecode2)) {
10297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10298 }
10299 arg2 = static_cast< int >(val2);
10300 }
10301 {
10302 if (!wxPyCheckForApp()) SWIG_fail;
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10305 wxPyEndAllowThreads(__tstate);
10306 if (PyErr_Occurred()) SWIG_fail;
10307 }
10308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10309 return resultobj;
10310 fail:
10311 return NULL;
10312 }
10313
10314
10315 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10316 PyObject *resultobj = 0;
10317 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10318 void *argp1 = 0 ;
10319 int res1 = 0 ;
10320 PyObject *swig_obj[1] ;
10321
10322 if (!args) SWIG_fail;
10323 swig_obj[0] = args;
10324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10325 if (!SWIG_IsOK(res1)) {
10326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10327 }
10328 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 delete arg1;
10332
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 resultobj = SWIG_Py_Void();
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10344 PyObject *resultobj = 0;
10345 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10346 PyObject *arg2 = (PyObject *) 0 ;
10347 PyObject *arg3 = (PyObject *) 0 ;
10348 int arg4 = (int) 1 ;
10349 void *argp1 = 0 ;
10350 int res1 = 0 ;
10351 int val4 ;
10352 int ecode4 = 0 ;
10353 PyObject * obj0 = 0 ;
10354 PyObject * obj1 = 0 ;
10355 PyObject * obj2 = 0 ;
10356 PyObject * obj3 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10367 arg2 = obj1;
10368 arg3 = obj2;
10369 if (obj3) {
10370 ecode4 = SWIG_AsVal_int(obj3, &val4);
10371 if (!SWIG_IsOK(ecode4)) {
10372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10373 }
10374 arg4 = static_cast< int >(val4);
10375 }
10376 {
10377 PyThreadState* __tstate = wxPyBeginAllowThreads();
10378 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10379 wxPyEndAllowThreads(__tstate);
10380 if (PyErr_Occurred()) SWIG_fail;
10381 }
10382 resultobj = SWIG_Py_Void();
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj = 0;
10391 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10392 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10393 int arg3 = (int) wxID_ANY ;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 void *argp2 = 0 ;
10397 int res2 = 0 ;
10398 int val3 ;
10399 int ecode3 = 0 ;
10400 PyObject * obj0 = 0 ;
10401 PyObject * obj1 = 0 ;
10402 PyObject * obj2 = 0 ;
10403 char * kwnames[] = {
10404 (char *) "self",(char *) "owner",(char *) "id", NULL
10405 };
10406
10407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10409 if (!SWIG_IsOK(res1)) {
10410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10411 }
10412 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10414 if (!SWIG_IsOK(res2)) {
10415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10416 }
10417 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10418 if (obj2) {
10419 ecode3 = SWIG_AsVal_int(obj2, &val3);
10420 if (!SWIG_IsOK(ecode3)) {
10421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10422 }
10423 arg3 = static_cast< int >(val3);
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 (arg1)->SetOwner(arg2,arg3);
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 resultobj = SWIG_Py_Void();
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10439 PyObject *resultobj = 0;
10440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10441 wxEvtHandler *result = 0 ;
10442 void *argp1 = 0 ;
10443 int res1 = 0 ;
10444 PyObject *swig_obj[1] ;
10445
10446 if (!args) SWIG_fail;
10447 swig_obj[0] = args;
10448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10451 }
10452 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 result = (wxEvtHandler *)(arg1)->GetOwner();
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 {
10460 resultobj = wxPyMake_wxObject(result, 0);
10461 }
10462 return resultobj;
10463 fail:
10464 return NULL;
10465 }
10466
10467
10468 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10469 PyObject *resultobj = 0;
10470 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10471 int arg2 = (int) -1 ;
10472 bool arg3 = (bool) false ;
10473 bool result;
10474 void *argp1 = 0 ;
10475 int res1 = 0 ;
10476 int val2 ;
10477 int ecode2 = 0 ;
10478 bool val3 ;
10479 int ecode3 = 0 ;
10480 PyObject * obj0 = 0 ;
10481 PyObject * obj1 = 0 ;
10482 PyObject * obj2 = 0 ;
10483 char * kwnames[] = {
10484 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10485 };
10486
10487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10489 if (!SWIG_IsOK(res1)) {
10490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10491 }
10492 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10493 if (obj1) {
10494 ecode2 = SWIG_AsVal_int(obj1, &val2);
10495 if (!SWIG_IsOK(ecode2)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10497 }
10498 arg2 = static_cast< int >(val2);
10499 }
10500 if (obj2) {
10501 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10502 if (!SWIG_IsOK(ecode3)) {
10503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10504 }
10505 arg3 = static_cast< bool >(val3);
10506 }
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 result = (bool)(arg1)->Start(arg2,arg3);
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 {
10514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10515 }
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 PyObject *resultobj = 0;
10524 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 PyObject *swig_obj[1] ;
10528
10529 if (!args) SWIG_fail;
10530 swig_obj[0] = args;
10531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 (arg1)->Stop();
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 resultobj = SWIG_Py_Void();
10543 return resultobj;
10544 fail:
10545 return NULL;
10546 }
10547
10548
10549 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10550 PyObject *resultobj = 0;
10551 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject *swig_obj[1] ;
10555
10556 if (!args) SWIG_fail;
10557 swig_obj[0] = args;
10558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 (arg1)->Notify();
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_Py_Void();
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10579 bool result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10599 }
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10609 int result;
10610 void *argp1 = 0 ;
10611 int res1 = 0 ;
10612 PyObject *swig_obj[1] ;
10613
10614 if (!args) SWIG_fail;
10615 swig_obj[0] = args;
10616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10619 }
10620 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_From_int(static_cast< int >(result));
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10635 PyObject *resultobj = 0;
10636 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10637 int result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 PyObject *swig_obj[1] ;
10641
10642 if (!args) SWIG_fail;
10643 swig_obj[0] = args;
10644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10647 }
10648 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10649 {
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = (int)((wxPyTimer const *)arg1)->GetId();
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_From_int(static_cast< int >(result));
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10663 PyObject *resultobj = 0;
10664 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10665 bool result;
10666 void *argp1 = 0 ;
10667 int res1 = 0 ;
10668 PyObject *swig_obj[1] ;
10669
10670 if (!args) SWIG_fail;
10671 swig_obj[0] = args;
10672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10673 if (!SWIG_IsOK(res1)) {
10674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10675 }
10676 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10677 {
10678 PyThreadState* __tstate = wxPyBeginAllowThreads();
10679 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 {
10684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10685 }
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10693 PyObject *obj;
10694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10696 return SWIG_Py_Void();
10697 }
10698
10699 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10700 return SWIG_Python_InitShadowInstance(args);
10701 }
10702
10703 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10704 PyObject *resultobj = 0;
10705 int arg1 = (int) 0 ;
10706 int arg2 = (int) 0 ;
10707 wxTimerEvent *result = 0 ;
10708 int val1 ;
10709 int ecode1 = 0 ;
10710 int val2 ;
10711 int ecode2 = 0 ;
10712 PyObject * obj0 = 0 ;
10713 PyObject * obj1 = 0 ;
10714 char * kwnames[] = {
10715 (char *) "timerid",(char *) "interval", NULL
10716 };
10717
10718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10719 if (obj0) {
10720 ecode1 = SWIG_AsVal_int(obj0, &val1);
10721 if (!SWIG_IsOK(ecode1)) {
10722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10723 }
10724 arg1 = static_cast< int >(val1);
10725 }
10726 if (obj1) {
10727 ecode2 = SWIG_AsVal_int(obj1, &val2);
10728 if (!SWIG_IsOK(ecode2)) {
10729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10730 }
10731 arg2 = static_cast< int >(val2);
10732 }
10733 {
10734 PyThreadState* __tstate = wxPyBeginAllowThreads();
10735 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10747 PyObject *resultobj = 0;
10748 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10749 int result;
10750 void *argp1 = 0 ;
10751 int res1 = 0 ;
10752 PyObject *swig_obj[1] ;
10753
10754 if (!args) SWIG_fail;
10755 swig_obj[0] = args;
10756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10757 if (!SWIG_IsOK(res1)) {
10758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10759 }
10760 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_From_int(static_cast< int >(result));
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *obj;
10776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10777 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10778 return SWIG_Py_Void();
10779 }
10780
10781 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10782 return SWIG_Python_InitShadowInstance(args);
10783 }
10784
10785 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10786 PyObject *resultobj = 0;
10787 wxTimer *arg1 = 0 ;
10788 wxTimerRunner *result = 0 ;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791
10792 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10794 if (!SWIG_IsOK(res1)) {
10795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10796 }
10797 if (!argp1) {
10798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10799 }
10800 arg1 = reinterpret_cast< wxTimer * >(argp1);
10801 {
10802 if (!wxPyCheckForApp()) SWIG_fail;
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10816 PyObject *resultobj = 0;
10817 wxTimer *arg1 = 0 ;
10818 int arg2 ;
10819 bool arg3 = (bool) false ;
10820 wxTimerRunner *result = 0 ;
10821 void *argp1 = 0 ;
10822 int res1 = 0 ;
10823 int val2 ;
10824 int ecode2 = 0 ;
10825 bool val3 ;
10826 int ecode3 = 0 ;
10827
10828 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10830 if (!SWIG_IsOK(res1)) {
10831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10832 }
10833 if (!argp1) {
10834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10835 }
10836 arg1 = reinterpret_cast< wxTimer * >(argp1);
10837 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10838 if (!SWIG_IsOK(ecode2)) {
10839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10840 }
10841 arg2 = static_cast< int >(val2);
10842 if (swig_obj[2]) {
10843 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10844 if (!SWIG_IsOK(ecode3)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10846 }
10847 arg3 = static_cast< bool >(val3);
10848 }
10849 {
10850 if (!wxPyCheckForApp()) SWIG_fail;
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10853 wxPyEndAllowThreads(__tstate);
10854 if (PyErr_Occurred()) SWIG_fail;
10855 }
10856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10857 return resultobj;
10858 fail:
10859 return NULL;
10860 }
10861
10862
10863 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10864 int argc;
10865 PyObject *argv[4];
10866
10867 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10868 --argc;
10869 if (argc == 1) {
10870 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10871 }
10872 if ((argc >= 2) && (argc <= 3)) {
10873 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10874 }
10875
10876 fail:
10877 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10883 PyObject *resultobj = 0;
10884 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10885 void *argp1 = 0 ;
10886 int res1 = 0 ;
10887 PyObject *swig_obj[1] ;
10888
10889 if (!args) SWIG_fail;
10890 swig_obj[0] = args;
10891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10894 }
10895 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 delete arg1;
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_Py_Void();
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj = 0;
10912 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10913 int arg2 ;
10914 bool arg3 = (bool) false ;
10915 void *argp1 = 0 ;
10916 int res1 = 0 ;
10917 int val2 ;
10918 int ecode2 = 0 ;
10919 bool val3 ;
10920 int ecode3 = 0 ;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 PyObject * obj2 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10932 }
10933 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10934 ecode2 = SWIG_AsVal_int(obj1, &val2);
10935 if (!SWIG_IsOK(ecode2)) {
10936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10937 }
10938 arg2 = static_cast< int >(val2);
10939 if (obj2) {
10940 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10941 if (!SWIG_IsOK(ecode3)) {
10942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10943 }
10944 arg3 = static_cast< bool >(val3);
10945 }
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 (arg1)->Start(arg2,arg3);
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 resultobj = SWIG_Py_Void();
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10960 PyObject *obj;
10961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10962 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10963 return SWIG_Py_Void();
10964 }
10965
10966 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10967 return SWIG_Python_InitShadowInstance(args);
10968 }
10969
10970 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 PyObject *resultobj = 0;
10972 wxLog *result = 0 ;
10973
10974 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (wxLog *)new wxLog();
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10989 PyObject *resultobj = 0;
10990 wxLog *arg1 = (wxLog *) 0 ;
10991 void *argp1 = 0 ;
10992 int res1 = 0 ;
10993 PyObject *swig_obj[1] ;
10994
10995 if (!args) SWIG_fail;
10996 swig_obj[0] = args;
10997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10998 if (!SWIG_IsOK(res1)) {
10999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11000 }
11001 arg1 = reinterpret_cast< wxLog * >(argp1);
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 delete arg1;
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 resultobj = SWIG_Py_Void();
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11017 PyObject *resultobj = 0;
11018 bool result;
11019
11020 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = (bool)wxLog::IsEnabled();
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 {
11028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11029 }
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 bool arg1 = (bool) true ;
11039 bool result;
11040 bool val1 ;
11041 int ecode1 = 0 ;
11042 PyObject * obj0 = 0 ;
11043 char * kwnames[] = {
11044 (char *) "doIt", NULL
11045 };
11046
11047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11048 if (obj0) {
11049 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11050 if (!SWIG_IsOK(ecode1)) {
11051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11052 }
11053 arg1 = static_cast< bool >(val1);
11054 }
11055 {
11056 PyThreadState* __tstate = wxPyBeginAllowThreads();
11057 result = (bool)wxLog::EnableLogging(arg1);
11058 wxPyEndAllowThreads(__tstate);
11059 if (PyErr_Occurred()) SWIG_fail;
11060 }
11061 {
11062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11063 }
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11071 PyObject *resultobj = 0;
11072 wxLogLevel arg1 ;
11073 wxChar *arg2 = (wxChar *) 0 ;
11074 time_t arg3 ;
11075 unsigned long val1 ;
11076 int ecode1 = 0 ;
11077 void *argp2 = 0 ;
11078 int res2 = 0 ;
11079 unsigned int val3 ;
11080 int ecode3 = 0 ;
11081 PyObject * obj0 = 0 ;
11082 PyObject * obj1 = 0 ;
11083 PyObject * obj2 = 0 ;
11084 char * kwnames[] = {
11085 (char *) "level",(char *) "szString",(char *) "t", NULL
11086 };
11087
11088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11089 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11090 if (!SWIG_IsOK(ecode1)) {
11091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11092 }
11093 arg1 = static_cast< wxLogLevel >(val1);
11094 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11095 if (!SWIG_IsOK(res2)) {
11096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11097 }
11098 arg2 = reinterpret_cast< wxChar * >(argp2);
11099 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11100 if (!SWIG_IsOK(ecode3)) {
11101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11102 }
11103 arg3 = static_cast< time_t >(val3);
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 resultobj = SWIG_Py_Void();
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 wxLog *arg1 = (wxLog *) 0 ;
11120 void *argp1 = 0 ;
11121 int res1 = 0 ;
11122 PyObject *swig_obj[1] ;
11123
11124 if (!args) SWIG_fail;
11125 swig_obj[0] = args;
11126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11127 if (!SWIG_IsOK(res1)) {
11128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11129 }
11130 arg1 = reinterpret_cast< wxLog * >(argp1);
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 (arg1)->Flush();
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 resultobj = SWIG_Py_Void();
11138 return resultobj;
11139 fail:
11140 return NULL;
11141 }
11142
11143
11144 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11145 PyObject *resultobj = 0;
11146
11147 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 wxLog::FlushActive();
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 resultobj = SWIG_Py_Void();
11155 return resultobj;
11156 fail:
11157 return NULL;
11158 }
11159
11160
11161 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11162 PyObject *resultobj = 0;
11163 wxLog *result = 0 ;
11164
11165 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11166 {
11167 PyThreadState* __tstate = wxPyBeginAllowThreads();
11168 result = (wxLog *)wxLog::GetActiveTarget();
11169 wxPyEndAllowThreads(__tstate);
11170 if (PyErr_Occurred()) SWIG_fail;
11171 }
11172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj = 0;
11181 wxLog *arg1 = (wxLog *) 0 ;
11182 wxLog *result = 0 ;
11183 int res1 = 0 ;
11184 PyObject * obj0 = 0 ;
11185 char * kwnames[] = {
11186 (char *) "pLogger", NULL
11187 };
11188
11189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11190 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11191 if (!SWIG_IsOK(res1)) {
11192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11193 }
11194 {
11195 PyThreadState* __tstate = wxPyBeginAllowThreads();
11196 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11197 wxPyEndAllowThreads(__tstate);
11198 if (PyErr_Occurred()) SWIG_fail;
11199 }
11200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11201 return resultobj;
11202 fail:
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11208 PyObject *resultobj = 0;
11209
11210 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11211 {
11212 PyThreadState* __tstate = wxPyBeginAllowThreads();
11213 wxLog::Suspend();
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 resultobj = SWIG_Py_Void();
11218 return resultobj;
11219 fail:
11220 return NULL;
11221 }
11222
11223
11224 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11225 PyObject *resultobj = 0;
11226
11227 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 wxLog::Resume();
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 resultobj = SWIG_Py_Void();
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj = 0;
11243 bool arg1 = (bool) true ;
11244 bool val1 ;
11245 int ecode1 = 0 ;
11246 PyObject * obj0 = 0 ;
11247 char * kwnames[] = {
11248 (char *) "bVerbose", NULL
11249 };
11250
11251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11252 if (obj0) {
11253 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11254 if (!SWIG_IsOK(ecode1)) {
11255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11256 }
11257 arg1 = static_cast< bool >(val1);
11258 }
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 wxLog::SetVerbose(arg1);
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 resultobj = SWIG_Py_Void();
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11273 PyObject *resultobj = 0;
11274 wxLogLevel arg1 ;
11275 unsigned long val1 ;
11276 int ecode1 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 char * kwnames[] = {
11279 (char *) "logLevel", NULL
11280 };
11281
11282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11283 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11284 if (!SWIG_IsOK(ecode1)) {
11285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11286 }
11287 arg1 = static_cast< wxLogLevel >(val1);
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 wxLog::SetLogLevel(arg1);
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 resultobj = SWIG_Py_Void();
11295 return resultobj;
11296 fail:
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302 PyObject *resultobj = 0;
11303
11304 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 wxLog::DontCreateOnDemand();
11308 wxPyEndAllowThreads(__tstate);
11309 if (PyErr_Occurred()) SWIG_fail;
11310 }
11311 resultobj = SWIG_Py_Void();
11312 return resultobj;
11313 fail:
11314 return NULL;
11315 }
11316
11317
11318 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj = 0;
11320 wxTraceMask arg1 ;
11321 unsigned long val1 ;
11322 int ecode1 = 0 ;
11323 PyObject * obj0 = 0 ;
11324 char * kwnames[] = {
11325 (char *) "ulMask", NULL
11326 };
11327
11328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11329 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11330 if (!SWIG_IsOK(ecode1)) {
11331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11332 }
11333 arg1 = static_cast< wxTraceMask >(val1);
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 wxLog::SetTraceMask(arg1);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj = 0;
11349 wxString *arg1 = 0 ;
11350 bool temp1 = false ;
11351 PyObject * obj0 = 0 ;
11352 char * kwnames[] = {
11353 (char *) "str", NULL
11354 };
11355
11356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11357 {
11358 arg1 = wxString_in_helper(obj0);
11359 if (arg1 == NULL) SWIG_fail;
11360 temp1 = true;
11361 }
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 wxLog::AddTraceMask((wxString const &)*arg1);
11365 wxPyEndAllowThreads(__tstate);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 resultobj = SWIG_Py_Void();
11369 {
11370 if (temp1)
11371 delete arg1;
11372 }
11373 return resultobj;
11374 fail:
11375 {
11376 if (temp1)
11377 delete arg1;
11378 }
11379 return NULL;
11380 }
11381
11382
11383 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj = 0;
11385 wxString *arg1 = 0 ;
11386 bool temp1 = false ;
11387 PyObject * obj0 = 0 ;
11388 char * kwnames[] = {
11389 (char *) "str", NULL
11390 };
11391
11392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11393 {
11394 arg1 = wxString_in_helper(obj0);
11395 if (arg1 == NULL) SWIG_fail;
11396 temp1 = true;
11397 }
11398 {
11399 PyThreadState* __tstate = wxPyBeginAllowThreads();
11400 wxLog::RemoveTraceMask((wxString const &)*arg1);
11401 wxPyEndAllowThreads(__tstate);
11402 if (PyErr_Occurred()) SWIG_fail;
11403 }
11404 resultobj = SWIG_Py_Void();
11405 {
11406 if (temp1)
11407 delete arg1;
11408 }
11409 return resultobj;
11410 fail:
11411 {
11412 if (temp1)
11413 delete arg1;
11414 }
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *resultobj = 0;
11421
11422 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 wxLog::ClearTraceMasks();
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_Py_Void();
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11437 PyObject *resultobj = 0;
11438 wxArrayString *result = 0 ;
11439
11440 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 {
11444 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11445 result = (wxArrayString *) &_result_ref;
11446 }
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 {
11451 resultobj = wxArrayString2PyList_helper(*result);
11452 }
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj = 0;
11461 wxChar *arg1 = (wxChar *) 0 ;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 PyObject * obj0 = 0 ;
11465 char * kwnames[] = {
11466 (char *) "ts", NULL
11467 };
11468
11469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11471 if (!SWIG_IsOK(res1)) {
11472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11473 }
11474 arg1 = reinterpret_cast< wxChar * >(argp1);
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 wxLog::SetTimestamp((wxChar const *)arg1);
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 resultobj = SWIG_Py_Void();
11482 return resultobj;
11483 fail:
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11489 PyObject *resultobj = 0;
11490 bool result;
11491
11492 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 result = (bool)wxLog::GetVerbose();
11496 wxPyEndAllowThreads(__tstate);
11497 if (PyErr_Occurred()) SWIG_fail;
11498 }
11499 {
11500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11501 }
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxTraceMask result;
11511
11512 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (wxTraceMask)wxLog::GetTraceMask();
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11520 return resultobj;
11521 fail:
11522 return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11527 PyObject *resultobj = 0;
11528 wxChar *arg1 = (wxChar *) 0 ;
11529 bool result;
11530 void *argp1 = 0 ;
11531 int res1 = 0 ;
11532 PyObject * obj0 = 0 ;
11533 char * kwnames[] = {
11534 (char *) "mask", NULL
11535 };
11536
11537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11539 if (!SWIG_IsOK(res1)) {
11540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11541 }
11542 arg1 = reinterpret_cast< wxChar * >(argp1);
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 {
11550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11551 }
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11559 PyObject *resultobj = 0;
11560 wxLogLevel result;
11561
11562 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 result = (wxLogLevel)wxLog::GetLogLevel();
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11577 PyObject *resultobj = 0;
11578 wxChar *result = 0 ;
11579
11580 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 result = (wxChar *)wxLog::GetTimestamp();
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11588 return resultobj;
11589 fail:
11590 return NULL;
11591 }
11592
11593
11594 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11595 PyObject *resultobj = 0;
11596 wxString result;
11597
11598 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11599 {
11600 PyThreadState* __tstate = wxPyBeginAllowThreads();
11601 result = wxLog_TimeStamp();
11602 wxPyEndAllowThreads(__tstate);
11603 if (PyErr_Occurred()) SWIG_fail;
11604 }
11605 {
11606 #if wxUSE_UNICODE
11607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11608 #else
11609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11610 #endif
11611 }
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11619 PyObject *resultobj = 0;
11620 wxLog *arg1 = (wxLog *) 0 ;
11621 void *argp1 = 0 ;
11622 int res1 = 0 ;
11623 PyObject *swig_obj[1] ;
11624
11625 if (!args) SWIG_fail;
11626 swig_obj[0] = args;
11627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11628 if (!SWIG_IsOK(res1)) {
11629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11630 }
11631 arg1 = reinterpret_cast< wxLog * >(argp1);
11632 {
11633 PyThreadState* __tstate = wxPyBeginAllowThreads();
11634 wxLog_Destroy(arg1);
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 resultobj = SWIG_Py_Void();
11639 return resultobj;
11640 fail:
11641 return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 PyObject *obj;
11647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11648 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11649 return SWIG_Py_Void();
11650 }
11651
11652 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11653 return SWIG_Python_InitShadowInstance(args);
11654 }
11655
11656 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 PyObject *resultobj = 0;
11658 wxLogStderr *result = 0 ;
11659
11660 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (wxLogStderr *)new wxLogStderr();
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11668 return resultobj;
11669 fail:
11670 return NULL;
11671 }
11672
11673
11674 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11675 PyObject *obj;
11676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11677 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11678 return SWIG_Py_Void();
11679 }
11680
11681 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11682 return SWIG_Python_InitShadowInstance(args);
11683 }
11684
11685 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11686 PyObject *resultobj = 0;
11687 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11688 wxLogTextCtrl *result = 0 ;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 PyObject * obj0 = 0 ;
11692 char * kwnames[] = {
11693 (char *) "pTextCtrl", NULL
11694 };
11695
11696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11698 if (!SWIG_IsOK(res1)) {
11699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11700 }
11701 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11702 {
11703 PyThreadState* __tstate = wxPyBeginAllowThreads();
11704 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *obj;
11717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11718 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11719 return SWIG_Py_Void();
11720 }
11721
11722 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 return SWIG_Python_InitShadowInstance(args);
11724 }
11725
11726 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 PyObject *resultobj = 0;
11728 wxLogGui *result = 0 ;
11729
11730 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (wxLogGui *)new wxLogGui();
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11745 PyObject *obj;
11746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11747 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11748 return SWIG_Py_Void();
11749 }
11750
11751 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 return SWIG_Python_InitShadowInstance(args);
11753 }
11754
11755 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11756 PyObject *resultobj = 0;
11757 wxFrame *arg1 = (wxFrame *) 0 ;
11758 wxString *arg2 = 0 ;
11759 bool arg3 = (bool) true ;
11760 bool arg4 = (bool) true ;
11761 wxLogWindow *result = 0 ;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 bool temp2 = false ;
11765 bool val3 ;
11766 int ecode3 = 0 ;
11767 bool val4 ;
11768 int ecode4 = 0 ;
11769 PyObject * obj0 = 0 ;
11770 PyObject * obj1 = 0 ;
11771 PyObject * obj2 = 0 ;
11772 PyObject * obj3 = 0 ;
11773 char * kwnames[] = {
11774 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11775 };
11776
11777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11779 if (!SWIG_IsOK(res1)) {
11780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11781 }
11782 arg1 = reinterpret_cast< wxFrame * >(argp1);
11783 {
11784 arg2 = wxString_in_helper(obj1);
11785 if (arg2 == NULL) SWIG_fail;
11786 temp2 = true;
11787 }
11788 if (obj2) {
11789 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11790 if (!SWIG_IsOK(ecode3)) {
11791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11792 }
11793 arg3 = static_cast< bool >(val3);
11794 }
11795 if (obj3) {
11796 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11797 if (!SWIG_IsOK(ecode4)) {
11798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11799 }
11800 arg4 = static_cast< bool >(val4);
11801 }
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11809 {
11810 if (temp2)
11811 delete arg2;
11812 }
11813 return resultobj;
11814 fail:
11815 {
11816 if (temp2)
11817 delete arg2;
11818 }
11819 return NULL;
11820 }
11821
11822
11823 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11824 PyObject *resultobj = 0;
11825 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11826 bool arg2 = (bool) true ;
11827 void *argp1 = 0 ;
11828 int res1 = 0 ;
11829 bool val2 ;
11830 int ecode2 = 0 ;
11831 PyObject * obj0 = 0 ;
11832 PyObject * obj1 = 0 ;
11833 char * kwnames[] = {
11834 (char *) "self",(char *) "bShow", NULL
11835 };
11836
11837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11839 if (!SWIG_IsOK(res1)) {
11840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11841 }
11842 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11843 if (obj1) {
11844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11845 if (!SWIG_IsOK(ecode2)) {
11846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11847 }
11848 arg2 = static_cast< bool >(val2);
11849 }
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 (arg1)->Show(arg2);
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 resultobj = SWIG_Py_Void();
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864 PyObject *resultobj = 0;
11865 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11866 wxFrame *result = 0 ;
11867 void *argp1 = 0 ;
11868 int res1 = 0 ;
11869 PyObject *swig_obj[1] ;
11870
11871 if (!args) SWIG_fail;
11872 swig_obj[0] = args;
11873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11876 }
11877 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = wxPyMake_wxObject(result, (bool)0);
11886 }
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11896 wxLog *result = 0 ;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11906 }
11907 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922 PyObject *resultobj = 0;
11923 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11924 bool result;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 if (!args) SWIG_fail;
11930 swig_obj[0] = args;
11931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11934 }
11935 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11954 bool arg2 ;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 bool val2 ;
11958 int ecode2 = 0 ;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 char * kwnames[] = {
11962 (char *) "self",(char *) "bDoPass", NULL
11963 };
11964
11965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11967 if (!SWIG_IsOK(res1)) {
11968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11969 }
11970 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11972 if (!SWIG_IsOK(ecode2)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11974 }
11975 arg2 = static_cast< bool >(val2);
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 (arg1)->PassMessages(arg2);
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_Py_Void();
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11990 PyObject *obj;
11991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11992 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11993 return SWIG_Py_Void();
11994 }
11995
11996 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11997 return SWIG_Python_InitShadowInstance(args);
11998 }
11999
12000 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12001 PyObject *resultobj = 0;
12002 wxLog *arg1 = (wxLog *) 0 ;
12003 wxLogChain *result = 0 ;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject * obj0 = 0 ;
12007 char * kwnames[] = {
12008 (char *) "logger", NULL
12009 };
12010
12011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12013 if (!SWIG_IsOK(res1)) {
12014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12015 }
12016 arg1 = reinterpret_cast< wxLog * >(argp1);
12017 {
12018 PyThreadState* __tstate = wxPyBeginAllowThreads();
12019 result = (wxLogChain *)new wxLogChain(arg1);
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj = 0;
12032 wxLogChain *arg1 = (wxLogChain *) 0 ;
12033 wxLog *arg2 = (wxLog *) 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 void *argp2 = 0 ;
12037 int res2 = 0 ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 char * kwnames[] = {
12041 (char *) "self",(char *) "logger", NULL
12042 };
12043
12044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12046 if (!SWIG_IsOK(res1)) {
12047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12048 }
12049 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12051 if (!SWIG_IsOK(res2)) {
12052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12053 }
12054 arg2 = reinterpret_cast< wxLog * >(argp2);
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 (arg1)->SetLog(arg2);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_Py_Void();
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12069 PyObject *resultobj = 0;
12070 wxLogChain *arg1 = (wxLogChain *) 0 ;
12071 bool arg2 ;
12072 void *argp1 = 0 ;
12073 int res1 = 0 ;
12074 bool val2 ;
12075 int ecode2 = 0 ;
12076 PyObject * obj0 = 0 ;
12077 PyObject * obj1 = 0 ;
12078 char * kwnames[] = {
12079 (char *) "self",(char *) "bDoPass", NULL
12080 };
12081
12082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12084 if (!SWIG_IsOK(res1)) {
12085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12086 }
12087 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12089 if (!SWIG_IsOK(ecode2)) {
12090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12091 }
12092 arg2 = static_cast< bool >(val2);
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 (arg1)->PassMessages(arg2);
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 resultobj = SWIG_Py_Void();
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxLogChain *arg1 = (wxLogChain *) 0 ;
12109 bool result;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12119 }
12120 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (bool)(arg1)->IsPassingMessages();
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12129 }
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12137 PyObject *resultobj = 0;
12138 wxLogChain *arg1 = (wxLogChain *) 0 ;
12139 wxLog *result = 0 ;
12140 void *argp1 = 0 ;
12141 int res1 = 0 ;
12142 PyObject *swig_obj[1] ;
12143
12144 if (!args) SWIG_fail;
12145 swig_obj[0] = args;
12146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12147 if (!SWIG_IsOK(res1)) {
12148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12149 }
12150 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (wxLog *)(arg1)->GetOldLog();
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12165 PyObject *obj;
12166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12167 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12168 return SWIG_Py_Void();
12169 }
12170
12171 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 return SWIG_Python_InitShadowInstance(args);
12173 }
12174
12175 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12176 PyObject *resultobj = 0;
12177 wxLogBuffer *result = 0 ;
12178
12179 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 result = (wxLogBuffer *)new wxLogBuffer();
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12194 PyObject *resultobj = 0;
12195 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12196 wxString *result = 0 ;
12197 void *argp1 = 0 ;
12198 int res1 = 0 ;
12199 PyObject *swig_obj[1] ;
12200
12201 if (!args) SWIG_fail;
12202 swig_obj[0] = args;
12203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12204 if (!SWIG_IsOK(res1)) {
12205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12206 }
12207 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 {
12211 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12212 result = (wxString *) &_result_ref;
12213 }
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 #if wxUSE_UNICODE
12219 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12220 #else
12221 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12222 #endif
12223 }
12224 return resultobj;
12225 fail:
12226 return NULL;
12227 }
12228
12229
12230 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12231 PyObject *obj;
12232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12233 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12234 return SWIG_Py_Void();
12235 }
12236
12237 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12238 return SWIG_Python_InitShadowInstance(args);
12239 }
12240
12241 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12242 PyObject *resultobj = 0;
12243 unsigned long result;
12244
12245 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12246 {
12247 PyThreadState* __tstate = wxPyBeginAllowThreads();
12248 result = (unsigned long)wxSysErrorCode();
12249 wxPyEndAllowThreads(__tstate);
12250 if (PyErr_Occurred()) SWIG_fail;
12251 }
12252 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj = 0;
12261 unsigned long arg1 = (unsigned long) 0 ;
12262 wxString result;
12263 unsigned long val1 ;
12264 int ecode1 = 0 ;
12265 PyObject * obj0 = 0 ;
12266 char * kwnames[] = {
12267 (char *) "nErrCode", NULL
12268 };
12269
12270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12271 if (obj0) {
12272 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12273 if (!SWIG_IsOK(ecode1)) {
12274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12275 }
12276 arg1 = static_cast< unsigned long >(val1);
12277 }
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = wxSysErrorMsg(arg1);
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 #if wxUSE_UNICODE
12286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12287 #else
12288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12289 #endif
12290 }
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj = 0;
12299 wxString *arg1 = 0 ;
12300 bool temp1 = false ;
12301 PyObject * obj0 = 0 ;
12302 char * kwnames[] = {
12303 (char *) "msg", NULL
12304 };
12305
12306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12307 {
12308 arg1 = wxString_in_helper(obj0);
12309 if (arg1 == NULL) SWIG_fail;
12310 temp1 = true;
12311 }
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 wxPyLogFatalError((wxString const &)*arg1);
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 resultobj = SWIG_Py_Void();
12319 {
12320 if (temp1)
12321 delete arg1;
12322 }
12323 return resultobj;
12324 fail:
12325 {
12326 if (temp1)
12327 delete arg1;
12328 }
12329 return NULL;
12330 }
12331
12332
12333 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj = 0;
12335 wxString *arg1 = 0 ;
12336 bool temp1 = false ;
12337 PyObject * obj0 = 0 ;
12338 char * kwnames[] = {
12339 (char *) "msg", NULL
12340 };
12341
12342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12343 {
12344 arg1 = wxString_in_helper(obj0);
12345 if (arg1 == NULL) SWIG_fail;
12346 temp1 = true;
12347 }
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 wxPyLogError((wxString const &)*arg1);
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 resultobj = SWIG_Py_Void();
12355 {
12356 if (temp1)
12357 delete arg1;
12358 }
12359 return resultobj;
12360 fail:
12361 {
12362 if (temp1)
12363 delete arg1;
12364 }
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj = 0;
12371 wxString *arg1 = 0 ;
12372 bool temp1 = false ;
12373 PyObject * obj0 = 0 ;
12374 char * kwnames[] = {
12375 (char *) "msg", NULL
12376 };
12377
12378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12379 {
12380 arg1 = wxString_in_helper(obj0);
12381 if (arg1 == NULL) SWIG_fail;
12382 temp1 = true;
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 wxPyLogWarning((wxString const &)*arg1);
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 resultobj = SWIG_Py_Void();
12391 {
12392 if (temp1)
12393 delete arg1;
12394 }
12395 return resultobj;
12396 fail:
12397 {
12398 if (temp1)
12399 delete arg1;
12400 }
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj = 0;
12407 wxString *arg1 = 0 ;
12408 bool temp1 = false ;
12409 PyObject * obj0 = 0 ;
12410 char * kwnames[] = {
12411 (char *) "msg", NULL
12412 };
12413
12414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12415 {
12416 arg1 = wxString_in_helper(obj0);
12417 if (arg1 == NULL) SWIG_fail;
12418 temp1 = true;
12419 }
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 wxPyLogMessage((wxString const &)*arg1);
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 resultobj = SWIG_Py_Void();
12427 {
12428 if (temp1)
12429 delete arg1;
12430 }
12431 return resultobj;
12432 fail:
12433 {
12434 if (temp1)
12435 delete arg1;
12436 }
12437 return NULL;
12438 }
12439
12440
12441 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = 0;
12443 wxString *arg1 = 0 ;
12444 bool temp1 = false ;
12445 PyObject * obj0 = 0 ;
12446 char * kwnames[] = {
12447 (char *) "msg", NULL
12448 };
12449
12450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12451 {
12452 arg1 = wxString_in_helper(obj0);
12453 if (arg1 == NULL) SWIG_fail;
12454 temp1 = true;
12455 }
12456 {
12457 PyThreadState* __tstate = wxPyBeginAllowThreads();
12458 wxPyLogInfo((wxString const &)*arg1);
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 resultobj = SWIG_Py_Void();
12463 {
12464 if (temp1)
12465 delete arg1;
12466 }
12467 return resultobj;
12468 fail:
12469 {
12470 if (temp1)
12471 delete arg1;
12472 }
12473 return NULL;
12474 }
12475
12476
12477 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12478 PyObject *resultobj = 0;
12479 wxString *arg1 = 0 ;
12480 bool temp1 = false ;
12481 PyObject * obj0 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "msg", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12487 {
12488 arg1 = wxString_in_helper(obj0);
12489 if (arg1 == NULL) SWIG_fail;
12490 temp1 = true;
12491 }
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 wxPyLogDebug((wxString const &)*arg1);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 {
12500 if (temp1)
12501 delete arg1;
12502 }
12503 return resultobj;
12504 fail:
12505 {
12506 if (temp1)
12507 delete arg1;
12508 }
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxString *arg1 = 0 ;
12516 bool temp1 = false ;
12517 PyObject * obj0 = 0 ;
12518 char * kwnames[] = {
12519 (char *) "msg", NULL
12520 };
12521
12522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12523 {
12524 arg1 = wxString_in_helper(obj0);
12525 if (arg1 == NULL) SWIG_fail;
12526 temp1 = true;
12527 }
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 wxPyLogVerbose((wxString const &)*arg1);
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 resultobj = SWIG_Py_Void();
12535 {
12536 if (temp1)
12537 delete arg1;
12538 }
12539 return resultobj;
12540 fail:
12541 {
12542 if (temp1)
12543 delete arg1;
12544 }
12545 return NULL;
12546 }
12547
12548
12549 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj = 0;
12551 wxString *arg1 = 0 ;
12552 bool temp1 = false ;
12553 PyObject * obj0 = 0 ;
12554 char * kwnames[] = {
12555 (char *) "msg", NULL
12556 };
12557
12558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12559 {
12560 arg1 = wxString_in_helper(obj0);
12561 if (arg1 == NULL) SWIG_fail;
12562 temp1 = true;
12563 }
12564 {
12565 PyThreadState* __tstate = wxPyBeginAllowThreads();
12566 wxPyLogStatus((wxString const &)*arg1);
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 resultobj = SWIG_Py_Void();
12571 {
12572 if (temp1)
12573 delete arg1;
12574 }
12575 return resultobj;
12576 fail:
12577 {
12578 if (temp1)
12579 delete arg1;
12580 }
12581 return NULL;
12582 }
12583
12584
12585 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj = 0;
12587 wxFrame *arg1 = (wxFrame *) 0 ;
12588 wxString *arg2 = 0 ;
12589 void *argp1 = 0 ;
12590 int res1 = 0 ;
12591 bool temp2 = false ;
12592 PyObject * obj0 = 0 ;
12593 PyObject * obj1 = 0 ;
12594 char * kwnames[] = {
12595 (char *) "pFrame",(char *) "msg", NULL
12596 };
12597
12598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12600 if (!SWIG_IsOK(res1)) {
12601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12602 }
12603 arg1 = reinterpret_cast< wxFrame * >(argp1);
12604 {
12605 arg2 = wxString_in_helper(obj1);
12606 if (arg2 == NULL) SWIG_fail;
12607 temp2 = true;
12608 }
12609 {
12610 PyThreadState* __tstate = wxPyBeginAllowThreads();
12611 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 resultobj = SWIG_Py_Void();
12616 {
12617 if (temp2)
12618 delete arg2;
12619 }
12620 return resultobj;
12621 fail:
12622 {
12623 if (temp2)
12624 delete arg2;
12625 }
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj = 0;
12632 wxString *arg1 = 0 ;
12633 bool temp1 = false ;
12634 PyObject * obj0 = 0 ;
12635 char * kwnames[] = {
12636 (char *) "msg", NULL
12637 };
12638
12639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12640 {
12641 arg1 = wxString_in_helper(obj0);
12642 if (arg1 == NULL) SWIG_fail;
12643 temp1 = true;
12644 }
12645 {
12646 PyThreadState* __tstate = wxPyBeginAllowThreads();
12647 wxPyLogSysError((wxString const &)*arg1);
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 resultobj = SWIG_Py_Void();
12652 {
12653 if (temp1)
12654 delete arg1;
12655 }
12656 return resultobj;
12657 fail:
12658 {
12659 if (temp1)
12660 delete arg1;
12661 }
12662 return NULL;
12663 }
12664
12665
12666 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj = 0;
12668 unsigned long arg1 ;
12669 wxString *arg2 = 0 ;
12670 unsigned long val1 ;
12671 int ecode1 = 0 ;
12672 bool temp2 = false ;
12673 PyObject * obj0 = 0 ;
12674 PyObject * obj1 = 0 ;
12675 char * kwnames[] = {
12676 (char *) "level",(char *) "msg", NULL
12677 };
12678
12679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12680 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12681 if (!SWIG_IsOK(ecode1)) {
12682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12683 }
12684 arg1 = static_cast< unsigned long >(val1);
12685 {
12686 arg2 = wxString_in_helper(obj1);
12687 if (arg2 == NULL) SWIG_fail;
12688 temp2 = true;
12689 }
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 resultobj = SWIG_Py_Void();
12697 {
12698 if (temp2)
12699 delete arg2;
12700 }
12701 return resultobj;
12702 fail:
12703 {
12704 if (temp2)
12705 delete arg2;
12706 }
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12712 PyObject *resultobj = 0;
12713 unsigned long arg1 ;
12714 wxString *arg2 = 0 ;
12715 unsigned long val1 ;
12716 int ecode1 = 0 ;
12717 bool temp2 = false ;
12718
12719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12720 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12721 if (!SWIG_IsOK(ecode1)) {
12722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12723 }
12724 arg1 = static_cast< unsigned long >(val1);
12725 {
12726 arg2 = wxString_in_helper(swig_obj[1]);
12727 if (arg2 == NULL) SWIG_fail;
12728 temp2 = true;
12729 }
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 wxPyLogTrace(arg1,(wxString const &)*arg2);
12733 wxPyEndAllowThreads(__tstate);
12734 if (PyErr_Occurred()) SWIG_fail;
12735 }
12736 resultobj = SWIG_Py_Void();
12737 {
12738 if (temp2)
12739 delete arg2;
12740 }
12741 return resultobj;
12742 fail:
12743 {
12744 if (temp2)
12745 delete arg2;
12746 }
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12752 PyObject *resultobj = 0;
12753 wxString *arg1 = 0 ;
12754 wxString *arg2 = 0 ;
12755 bool temp1 = false ;
12756 bool temp2 = false ;
12757
12758 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12759 {
12760 arg1 = wxString_in_helper(swig_obj[0]);
12761 if (arg1 == NULL) SWIG_fail;
12762 temp1 = true;
12763 }
12764 {
12765 arg2 = wxString_in_helper(swig_obj[1]);
12766 if (arg2 == NULL) SWIG_fail;
12767 temp2 = true;
12768 }
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 resultobj = SWIG_Py_Void();
12776 {
12777 if (temp1)
12778 delete arg1;
12779 }
12780 {
12781 if (temp2)
12782 delete arg2;
12783 }
12784 return resultobj;
12785 fail:
12786 {
12787 if (temp1)
12788 delete arg1;
12789 }
12790 {
12791 if (temp2)
12792 delete arg2;
12793 }
12794 return NULL;
12795 }
12796
12797
12798 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12799 int argc;
12800 PyObject *argv[3];
12801
12802 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12803 --argc;
12804 if (argc == 2) {
12805 int _v = 0;
12806 {
12807 {
12808 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12809 }
12810 }
12811 if (!_v) goto check_1;
12812 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12813 }
12814 check_1:
12815
12816 if (argc == 2) {
12817 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12818 }
12819
12820 fail:
12821 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj = 0;
12828 wxString *arg1 = 0 ;
12829 wxString *arg2 = 0 ;
12830 bool temp1 = false ;
12831 bool temp2 = false ;
12832 PyObject * obj0 = 0 ;
12833 PyObject * obj1 = 0 ;
12834 char * kwnames[] = {
12835 (char *) "title",(char *) "text", NULL
12836 };
12837
12838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12839 {
12840 arg1 = wxString_in_helper(obj0);
12841 if (arg1 == NULL) SWIG_fail;
12842 temp1 = true;
12843 }
12844 {
12845 arg2 = wxString_in_helper(obj1);
12846 if (arg2 == NULL) SWIG_fail;
12847 temp2 = true;
12848 }
12849 {
12850 PyThreadState* __tstate = wxPyBeginAllowThreads();
12851 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12852 wxPyEndAllowThreads(__tstate);
12853 if (PyErr_Occurred()) SWIG_fail;
12854 }
12855 resultobj = SWIG_Py_Void();
12856 {
12857 if (temp1)
12858 delete arg1;
12859 }
12860 {
12861 if (temp2)
12862 delete arg2;
12863 }
12864 return resultobj;
12865 fail:
12866 {
12867 if (temp1)
12868 delete arg1;
12869 }
12870 {
12871 if (temp2)
12872 delete arg2;
12873 }
12874 return NULL;
12875 }
12876
12877
12878 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 PyObject *resultobj = 0;
12880 wxLogNull *result = 0 ;
12881
12882 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (wxLogNull *)new wxLogNull();
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 PyObject *resultobj = 0;
12898 wxLogNull *arg1 = (wxLogNull *) 0 ;
12899 void *argp1 = 0 ;
12900 int res1 = 0 ;
12901 PyObject *swig_obj[1] ;
12902
12903 if (!args) SWIG_fail;
12904 swig_obj[0] = args;
12905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12908 }
12909 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 delete arg1;
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 resultobj = SWIG_Py_Void();
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 PyObject *obj;
12926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12927 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12928 return SWIG_Py_Void();
12929 }
12930
12931 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12932 return SWIG_Python_InitShadowInstance(args);
12933 }
12934
12935 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12936 PyObject *resultobj = 0;
12937 wxPyLog *result = 0 ;
12938
12939 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (wxPyLog *)new wxPyLog();
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12954 PyObject *resultobj = 0;
12955 wxPyLog *arg1 = (wxPyLog *) 0 ;
12956 PyObject *arg2 = (PyObject *) 0 ;
12957 PyObject *arg3 = (PyObject *) 0 ;
12958 void *argp1 = 0 ;
12959 int res1 = 0 ;
12960 PyObject * obj0 = 0 ;
12961 PyObject * obj1 = 0 ;
12962 PyObject * obj2 = 0 ;
12963 char * kwnames[] = {
12964 (char *) "self",(char *) "self",(char *) "_class", NULL
12965 };
12966
12967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12969 if (!SWIG_IsOK(res1)) {
12970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12971 }
12972 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12973 arg2 = obj1;
12974 arg3 = obj2;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 (arg1)->_setCallbackInfo(arg2,arg3);
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_Py_Void();
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 PyObject *obj;
12990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12991 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12992 return SWIG_Py_Void();
12993 }
12994
12995 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 return SWIG_Python_InitShadowInstance(args);
12997 }
12998
12999 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj = 0;
13001 int arg1 ;
13002 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13003 int arg3 = (int) wxKILL_NOCHILDREN ;
13004 wxKillError result;
13005 int val1 ;
13006 int ecode1 = 0 ;
13007 int val2 ;
13008 int ecode2 = 0 ;
13009 int val3 ;
13010 int ecode3 = 0 ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 PyObject * obj2 = 0 ;
13014 char * kwnames[] = {
13015 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13016 };
13017
13018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13019 ecode1 = SWIG_AsVal_int(obj0, &val1);
13020 if (!SWIG_IsOK(ecode1)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13022 }
13023 arg1 = static_cast< int >(val1);
13024 if (obj1) {
13025 ecode2 = SWIG_AsVal_int(obj1, &val2);
13026 if (!SWIG_IsOK(ecode2)) {
13027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13028 }
13029 arg2 = static_cast< wxSignal >(val2);
13030 }
13031 if (obj2) {
13032 ecode3 = SWIG_AsVal_int(obj2, &val3);
13033 if (!SWIG_IsOK(ecode3)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13035 }
13036 arg3 = static_cast< int >(val3);
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 resultobj = SWIG_From_int(static_cast< int >(result));
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj = 0;
13053 int arg1 ;
13054 bool result;
13055 int val1 ;
13056 int ecode1 = 0 ;
13057 PyObject * obj0 = 0 ;
13058 char * kwnames[] = {
13059 (char *) "pid", NULL
13060 };
13061
13062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13063 ecode1 = SWIG_AsVal_int(obj0, &val1);
13064 if (!SWIG_IsOK(ecode1)) {
13065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13066 }
13067 arg1 = static_cast< int >(val1);
13068 {
13069 PyThreadState* __tstate = wxPyBeginAllowThreads();
13070 result = (bool)wxPyProcess::Exists(arg1);
13071 wxPyEndAllowThreads(__tstate);
13072 if (PyErr_Occurred()) SWIG_fail;
13073 }
13074 {
13075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj = 0;
13085 wxString *arg1 = 0 ;
13086 int arg2 = (int) wxEXEC_ASYNC ;
13087 wxPyProcess *result = 0 ;
13088 bool temp1 = false ;
13089 int val2 ;
13090 int ecode2 = 0 ;
13091 PyObject * obj0 = 0 ;
13092 PyObject * obj1 = 0 ;
13093 char * kwnames[] = {
13094 (char *) "cmd",(char *) "flags", NULL
13095 };
13096
13097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13098 {
13099 arg1 = wxString_in_helper(obj0);
13100 if (arg1 == NULL) SWIG_fail;
13101 temp1 = true;
13102 }
13103 if (obj1) {
13104 ecode2 = SWIG_AsVal_int(obj1, &val2);
13105 if (!SWIG_IsOK(ecode2)) {
13106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13107 }
13108 arg2 = static_cast< int >(val2);
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13117 {
13118 if (temp1)
13119 delete arg1;
13120 }
13121 return resultobj;
13122 fail:
13123 {
13124 if (temp1)
13125 delete arg1;
13126 }
13127 return NULL;
13128 }
13129
13130
13131 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj = 0;
13133 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13134 int arg2 = (int) -1 ;
13135 wxPyProcess *result = 0 ;
13136 void *argp1 = 0 ;
13137 int res1 = 0 ;
13138 int val2 ;
13139 int ecode2 = 0 ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "parent",(char *) "id", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13147 if (obj0) {
13148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13149 if (!SWIG_IsOK(res1)) {
13150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13151 }
13152 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13153 }
13154 if (obj1) {
13155 ecode2 = SWIG_AsVal_int(obj1, &val2);
13156 if (!SWIG_IsOK(ecode2)) {
13157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13158 }
13159 arg2 = static_cast< int >(val2);
13160 }
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13164 wxPyEndAllowThreads(__tstate);
13165 if (PyErr_Occurred()) SWIG_fail;
13166 }
13167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13168 return resultobj;
13169 fail:
13170 return NULL;
13171 }
13172
13173
13174 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj = 0;
13176 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13177 PyObject *arg2 = (PyObject *) 0 ;
13178 PyObject *arg3 = (PyObject *) 0 ;
13179 void *argp1 = 0 ;
13180 int res1 = 0 ;
13181 PyObject * obj0 = 0 ;
13182 PyObject * obj1 = 0 ;
13183 PyObject * obj2 = 0 ;
13184 char * kwnames[] = {
13185 (char *) "self",(char *) "self",(char *) "_class", NULL
13186 };
13187
13188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13190 if (!SWIG_IsOK(res1)) {
13191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13192 }
13193 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13194 arg2 = obj1;
13195 arg3 = obj2;
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 (arg1)->_setCallbackInfo(arg2,arg3);
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 resultobj = SWIG_Py_Void();
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj = 0;
13211 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13212 int arg2 ;
13213 int arg3 ;
13214 void *argp1 = 0 ;
13215 int res1 = 0 ;
13216 int val2 ;
13217 int ecode2 = 0 ;
13218 int val3 ;
13219 int ecode3 = 0 ;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 PyObject * obj2 = 0 ;
13223 char * kwnames[] = {
13224 (char *) "self",(char *) "pid",(char *) "status", NULL
13225 };
13226
13227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13229 if (!SWIG_IsOK(res1)) {
13230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13231 }
13232 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13233 ecode2 = SWIG_AsVal_int(obj1, &val2);
13234 if (!SWIG_IsOK(ecode2)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13236 }
13237 arg2 = static_cast< int >(val2);
13238 ecode3 = SWIG_AsVal_int(obj2, &val3);
13239 if (!SWIG_IsOK(ecode3)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13241 }
13242 arg3 = static_cast< int >(val3);
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 (arg1)->OnTerminate(arg2,arg3);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 resultobj = SWIG_Py_Void();
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13257 PyObject *resultobj = 0;
13258 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 PyObject *swig_obj[1] ;
13262
13263 if (!args) SWIG_fail;
13264 swig_obj[0] = args;
13265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13266 if (!SWIG_IsOK(res1)) {
13267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13268 }
13269 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 (arg1)->Redirect();
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 resultobj = SWIG_Py_Void();
13277 return resultobj;
13278 fail:
13279 return NULL;
13280 }
13281
13282
13283 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13284 PyObject *resultobj = 0;
13285 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13286 bool result;
13287 void *argp1 = 0 ;
13288 int res1 = 0 ;
13289 PyObject *swig_obj[1] ;
13290
13291 if (!args) SWIG_fail;
13292 swig_obj[0] = args;
13293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13294 if (!SWIG_IsOK(res1)) {
13295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13296 }
13297 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = (bool)(arg1)->IsRedirected();
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 {
13305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13306 }
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13314 PyObject *resultobj = 0;
13315 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 PyObject *swig_obj[1] ;
13319
13320 if (!args) SWIG_fail;
13321 swig_obj[0] = args;
13322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13325 }
13326 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13327 {
13328 PyThreadState* __tstate = wxPyBeginAllowThreads();
13329 (arg1)->Detach();
13330 wxPyEndAllowThreads(__tstate);
13331 if (PyErr_Occurred()) SWIG_fail;
13332 }
13333 resultobj = SWIG_Py_Void();
13334 return resultobj;
13335 fail:
13336 return NULL;
13337 }
13338
13339
13340 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13341 PyObject *resultobj = 0;
13342 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13343 wxInputStream *result = 0 ;
13344 void *argp1 = 0 ;
13345 int res1 = 0 ;
13346 PyObject *swig_obj[1] ;
13347
13348 if (!args) SWIG_fail;
13349 swig_obj[0] = args;
13350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13351 if (!SWIG_IsOK(res1)) {
13352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13353 }
13354 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (wxInputStream *)(arg1)->GetInputStream();
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 {
13362 wxPyInputStream * _ptr = NULL;
13363
13364 if (result) {
13365 _ptr = new wxPyInputStream(result);
13366 }
13367 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13368 }
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13376 PyObject *resultobj = 0;
13377 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13378 wxInputStream *result = 0 ;
13379 void *argp1 = 0 ;
13380 int res1 = 0 ;
13381 PyObject *swig_obj[1] ;
13382
13383 if (!args) SWIG_fail;
13384 swig_obj[0] = args;
13385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13386 if (!SWIG_IsOK(res1)) {
13387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13388 }
13389 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13390 {
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (wxInputStream *)(arg1)->GetErrorStream();
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 {
13397 wxPyInputStream * _ptr = NULL;
13398
13399 if (result) {
13400 _ptr = new wxPyInputStream(result);
13401 }
13402 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13403 }
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13411 PyObject *resultobj = 0;
13412 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13413 wxOutputStream *result = 0 ;
13414 void *argp1 = 0 ;
13415 int res1 = 0 ;
13416 PyObject *swig_obj[1] ;
13417
13418 if (!args) SWIG_fail;
13419 swig_obj[0] = args;
13420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13421 if (!SWIG_IsOK(res1)) {
13422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13423 }
13424 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = (wxOutputStream *)(arg1)->GetOutputStream();
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13441 void *argp1 = 0 ;
13442 int res1 = 0 ;
13443 PyObject *swig_obj[1] ;
13444
13445 if (!args) SWIG_fail;
13446 swig_obj[0] = args;
13447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13450 }
13451 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 (arg1)->CloseOutput();
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_Py_Void();
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13466 PyObject *resultobj = 0;
13467 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13468 bool result;
13469 void *argp1 = 0 ;
13470 int res1 = 0 ;
13471 PyObject *swig_obj[1] ;
13472
13473 if (!args) SWIG_fail;
13474 swig_obj[0] = args;
13475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13476 if (!SWIG_IsOK(res1)) {
13477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13478 }
13479 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 {
13487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13488 }
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13496 PyObject *resultobj = 0;
13497 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13498 bool result;
13499 void *argp1 = 0 ;
13500 int res1 = 0 ;
13501 PyObject *swig_obj[1] ;
13502
13503 if (!args) SWIG_fail;
13504 swig_obj[0] = args;
13505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13506 if (!SWIG_IsOK(res1)) {
13507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13508 }
13509 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 {
13517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13518 }
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13526 PyObject *resultobj = 0;
13527 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13528 bool result;
13529 void *argp1 = 0 ;
13530 int res1 = 0 ;
13531 PyObject *swig_obj[1] ;
13532
13533 if (!args) SWIG_fail;
13534 swig_obj[0] = args;
13535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13536 if (!SWIG_IsOK(res1)) {
13537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13538 }
13539 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 {
13547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13548 }
13549 return resultobj;
13550 fail:
13551 return NULL;
13552 }
13553
13554
13555 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13556 PyObject *obj;
13557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13558 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13559 return SWIG_Py_Void();
13560 }
13561
13562 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13563 return SWIG_Python_InitShadowInstance(args);
13564 }
13565
13566 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13567 PyObject *resultobj = 0;
13568 int arg1 = (int) 0 ;
13569 int arg2 = (int) 0 ;
13570 int arg3 = (int) 0 ;
13571 wxProcessEvent *result = 0 ;
13572 int val1 ;
13573 int ecode1 = 0 ;
13574 int val2 ;
13575 int ecode2 = 0 ;
13576 int val3 ;
13577 int ecode3 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13586 if (obj0) {
13587 ecode1 = SWIG_AsVal_int(obj0, &val1);
13588 if (!SWIG_IsOK(ecode1)) {
13589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13590 }
13591 arg1 = static_cast< int >(val1);
13592 }
13593 if (obj1) {
13594 ecode2 = SWIG_AsVal_int(obj1, &val2);
13595 if (!SWIG_IsOK(ecode2)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13597 }
13598 arg2 = static_cast< int >(val2);
13599 }
13600 if (obj2) {
13601 ecode3 = SWIG_AsVal_int(obj2, &val3);
13602 if (!SWIG_IsOK(ecode3)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13604 }
13605 arg3 = static_cast< int >(val3);
13606 }
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13621 PyObject *resultobj = 0;
13622 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13623 int result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 PyObject *swig_obj[1] ;
13627
13628 if (!args) SWIG_fail;
13629 swig_obj[0] = args;
13630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13633 }
13634 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (int)(arg1)->GetPid();
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_From_int(static_cast< int >(result));
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13649 PyObject *resultobj = 0;
13650 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13651 int result;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 PyObject *swig_obj[1] ;
13655
13656 if (!args) SWIG_fail;
13657 swig_obj[0] = args;
13658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13659 if (!SWIG_IsOK(res1)) {
13660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13661 }
13662 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (int)(arg1)->GetExitCode();
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_From_int(static_cast< int >(result));
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13677 PyObject *resultobj = 0;
13678 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13679 int arg2 ;
13680 void *argp1 = 0 ;
13681 int res1 = 0 ;
13682 int val2 ;
13683 int ecode2 = 0 ;
13684 PyObject *swig_obj[2] ;
13685
13686 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13690 }
13691 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13692 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13693 if (!SWIG_IsOK(ecode2)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13695 }
13696 arg2 = static_cast< int >(val2);
13697 if (arg1) (arg1)->m_pid = arg2;
13698
13699 resultobj = SWIG_Py_Void();
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13707 PyObject *resultobj = 0;
13708 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13709 int result;
13710 void *argp1 = 0 ;
13711 int res1 = 0 ;
13712 PyObject *swig_obj[1] ;
13713
13714 if (!args) SWIG_fail;
13715 swig_obj[0] = args;
13716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13719 }
13720 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13721 result = (int) ((arg1)->m_pid);
13722 resultobj = SWIG_From_int(static_cast< int >(result));
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13730 PyObject *resultobj = 0;
13731 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13732 int arg2 ;
13733 void *argp1 = 0 ;
13734 int res1 = 0 ;
13735 int val2 ;
13736 int ecode2 = 0 ;
13737 PyObject *swig_obj[2] ;
13738
13739 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13741 if (!SWIG_IsOK(res1)) {
13742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13743 }
13744 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13745 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13746 if (!SWIG_IsOK(ecode2)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13748 }
13749 arg2 = static_cast< int >(val2);
13750 if (arg1) (arg1)->m_exitcode = arg2;
13751
13752 resultobj = SWIG_Py_Void();
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13760 PyObject *resultobj = 0;
13761 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13762 int result;
13763 void *argp1 = 0 ;
13764 int res1 = 0 ;
13765 PyObject *swig_obj[1] ;
13766
13767 if (!args) SWIG_fail;
13768 swig_obj[0] = args;
13769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13770 if (!SWIG_IsOK(res1)) {
13771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13772 }
13773 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13774 result = (int) ((arg1)->m_exitcode);
13775 resultobj = SWIG_From_int(static_cast< int >(result));
13776 return resultobj;
13777 fail:
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13783 PyObject *obj;
13784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13785 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13786 return SWIG_Py_Void();
13787 }
13788
13789 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 return SWIG_Python_InitShadowInstance(args);
13791 }
13792
13793 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 wxString *arg1 = 0 ;
13796 int arg2 = (int) wxEXEC_ASYNC ;
13797 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13798 long result;
13799 bool temp1 = false ;
13800 int val2 ;
13801 int ecode2 = 0 ;
13802 void *argp3 = 0 ;
13803 int res3 = 0 ;
13804 PyObject * obj0 = 0 ;
13805 PyObject * obj1 = 0 ;
13806 PyObject * obj2 = 0 ;
13807 char * kwnames[] = {
13808 (char *) "command",(char *) "flags",(char *) "process", NULL
13809 };
13810
13811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13812 {
13813 arg1 = wxString_in_helper(obj0);
13814 if (arg1 == NULL) SWIG_fail;
13815 temp1 = true;
13816 }
13817 if (obj1) {
13818 ecode2 = SWIG_AsVal_int(obj1, &val2);
13819 if (!SWIG_IsOK(ecode2)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13821 }
13822 arg2 = static_cast< int >(val2);
13823 }
13824 if (obj2) {
13825 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13826 if (!SWIG_IsOK(res3)) {
13827 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13828 }
13829 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13830 }
13831 {
13832 if (!wxPyCheckForApp()) SWIG_fail;
13833 PyThreadState* __tstate = wxPyBeginAllowThreads();
13834 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13835 wxPyEndAllowThreads(__tstate);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 }
13838 resultobj = SWIG_From_long(static_cast< long >(result));
13839 {
13840 if (temp1)
13841 delete arg1;
13842 }
13843 return resultobj;
13844 fail:
13845 {
13846 if (temp1)
13847 delete arg1;
13848 }
13849 return NULL;
13850 }
13851
13852
13853 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj = 0;
13855 long arg1 ;
13856 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13857 wxKillError *arg3 = (wxKillError *) 0 ;
13858 int arg4 = (int) wxKILL_NOCHILDREN ;
13859 int result;
13860 long val1 ;
13861 int ecode1 = 0 ;
13862 int val2 ;
13863 int ecode2 = 0 ;
13864 wxKillError temp3 ;
13865 int val4 ;
13866 int ecode4 = 0 ;
13867 PyObject * obj0 = 0 ;
13868 PyObject * obj1 = 0 ;
13869 PyObject * obj2 = 0 ;
13870 char * kwnames[] = {
13871 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13872 };
13873
13874 {
13875 arg3 = &temp3;
13876 }
13877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13878 ecode1 = SWIG_AsVal_long(obj0, &val1);
13879 if (!SWIG_IsOK(ecode1)) {
13880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13881 }
13882 arg1 = static_cast< long >(val1);
13883 if (obj1) {
13884 ecode2 = SWIG_AsVal_int(obj1, &val2);
13885 if (!SWIG_IsOK(ecode2)) {
13886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13887 }
13888 arg2 = static_cast< wxSignal >(val2);
13889 }
13890 if (obj2) {
13891 ecode4 = SWIG_AsVal_int(obj2, &val4);
13892 if (!SWIG_IsOK(ecode4)) {
13893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13894 }
13895 arg4 = static_cast< int >(val4);
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 result = (int)wxKill(arg1,arg2,arg3,arg4);
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_From_int(static_cast< int >(result));
13904 {
13905 PyObject* o;
13906 o = PyInt_FromLong((long) (*arg3));
13907
13908
13909
13910 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13911
13912 }
13913 return resultobj;
13914 fail:
13915 return NULL;
13916 }
13917
13918
13919 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj = 0;
13921 int arg1 = (int) wxJOYSTICK1 ;
13922 wxJoystick *result = 0 ;
13923 int val1 ;
13924 int ecode1 = 0 ;
13925 PyObject * obj0 = 0 ;
13926 char * kwnames[] = {
13927 (char *) "joystick", NULL
13928 };
13929
13930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13931 if (obj0) {
13932 ecode1 = SWIG_AsVal_int(obj0, &val1);
13933 if (!SWIG_IsOK(ecode1)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13935 }
13936 arg1 = static_cast< int >(val1);
13937 }
13938 {
13939 if (!wxPyCheckForApp()) SWIG_fail;
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 result = (wxJoystick *)new wxJoystick(arg1);
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13953 PyObject *resultobj = 0;
13954 wxJoystick *arg1 = (wxJoystick *) 0 ;
13955 void *argp1 = 0 ;
13956 int res1 = 0 ;
13957 PyObject *swig_obj[1] ;
13958
13959 if (!args) SWIG_fail;
13960 swig_obj[0] = args;
13961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13962 if (!SWIG_IsOK(res1)) {
13963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13964 }
13965 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 delete arg1;
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_Py_Void();
13974 return resultobj;
13975 fail:
13976 return NULL;
13977 }
13978
13979
13980 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13981 PyObject *resultobj = 0;
13982 wxJoystick *arg1 = (wxJoystick *) 0 ;
13983 wxPoint result;
13984 void *argp1 = 0 ;
13985 int res1 = 0 ;
13986 PyObject *swig_obj[1] ;
13987
13988 if (!args) SWIG_fail;
13989 swig_obj[0] = args;
13990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13991 if (!SWIG_IsOK(res1)) {
13992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13993 }
13994 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (arg1)->GetPosition();
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14009 PyObject *resultobj = 0;
14010 wxJoystick *arg1 = (wxJoystick *) 0 ;
14011 int result;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 PyObject *swig_obj[1] ;
14015
14016 if (!args) SWIG_fail;
14017 swig_obj[0] = args;
14018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14021 }
14022 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 result = (int)(arg1)->GetZPosition();
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_From_int(static_cast< int >(result));
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14037 PyObject *resultobj = 0;
14038 wxJoystick *arg1 = (wxJoystick *) 0 ;
14039 int result;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 PyObject *swig_obj[1] ;
14043
14044 if (!args) SWIG_fail;
14045 swig_obj[0] = args;
14046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14049 }
14050 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (int)(arg1)->GetButtonState();
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 resultobj = SWIG_From_int(static_cast< int >(result));
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14065 PyObject *resultobj = 0;
14066 wxJoystick *arg1 = (wxJoystick *) 0 ;
14067 int result;
14068 void *argp1 = 0 ;
14069 int res1 = 0 ;
14070 PyObject *swig_obj[1] ;
14071
14072 if (!args) SWIG_fail;
14073 swig_obj[0] = args;
14074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14075 if (!SWIG_IsOK(res1)) {
14076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14077 }
14078 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (int)(arg1)->GetPOVPosition();
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_From_int(static_cast< int >(result));
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14093 PyObject *resultobj = 0;
14094 wxJoystick *arg1 = (wxJoystick *) 0 ;
14095 int result;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 PyObject *swig_obj[1] ;
14099
14100 if (!args) SWIG_fail;
14101 swig_obj[0] = args;
14102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14103 if (!SWIG_IsOK(res1)) {
14104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14105 }
14106 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14107 {
14108 PyThreadState* __tstate = wxPyBeginAllowThreads();
14109 result = (int)(arg1)->GetPOVCTSPosition();
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 resultobj = SWIG_From_int(static_cast< int >(result));
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14121 PyObject *resultobj = 0;
14122 wxJoystick *arg1 = (wxJoystick *) 0 ;
14123 int result;
14124 void *argp1 = 0 ;
14125 int res1 = 0 ;
14126 PyObject *swig_obj[1] ;
14127
14128 if (!args) SWIG_fail;
14129 swig_obj[0] = args;
14130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14131 if (!SWIG_IsOK(res1)) {
14132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14133 }
14134 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (int)(arg1)->GetRudderPosition();
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 resultobj = SWIG_From_int(static_cast< int >(result));
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14149 PyObject *resultobj = 0;
14150 wxJoystick *arg1 = (wxJoystick *) 0 ;
14151 int result;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 PyObject *swig_obj[1] ;
14155
14156 if (!args) SWIG_fail;
14157 swig_obj[0] = args;
14158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14159 if (!SWIG_IsOK(res1)) {
14160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14161 }
14162 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (int)(arg1)->GetUPosition();
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 resultobj = SWIG_From_int(static_cast< int >(result));
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14177 PyObject *resultobj = 0;
14178 wxJoystick *arg1 = (wxJoystick *) 0 ;
14179 int result;
14180 void *argp1 = 0 ;
14181 int res1 = 0 ;
14182 PyObject *swig_obj[1] ;
14183
14184 if (!args) SWIG_fail;
14185 swig_obj[0] = args;
14186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14187 if (!SWIG_IsOK(res1)) {
14188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14189 }
14190 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (int)(arg1)->GetVPosition();
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 resultobj = SWIG_From_int(static_cast< int >(result));
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14205 PyObject *resultobj = 0;
14206 wxJoystick *arg1 = (wxJoystick *) 0 ;
14207 int result;
14208 void *argp1 = 0 ;
14209 int res1 = 0 ;
14210 PyObject *swig_obj[1] ;
14211
14212 if (!args) SWIG_fail;
14213 swig_obj[0] = args;
14214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14215 if (!SWIG_IsOK(res1)) {
14216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14217 }
14218 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 result = (int)(arg1)->GetMovementThreshold();
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 resultobj = SWIG_From_int(static_cast< int >(result));
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14233 PyObject *resultobj = 0;
14234 wxJoystick *arg1 = (wxJoystick *) 0 ;
14235 int arg2 ;
14236 void *argp1 = 0 ;
14237 int res1 = 0 ;
14238 int val2 ;
14239 int ecode2 = 0 ;
14240 PyObject * obj0 = 0 ;
14241 PyObject * obj1 = 0 ;
14242 char * kwnames[] = {
14243 (char *) "self",(char *) "threshold", NULL
14244 };
14245
14246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14248 if (!SWIG_IsOK(res1)) {
14249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14250 }
14251 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14252 ecode2 = SWIG_AsVal_int(obj1, &val2);
14253 if (!SWIG_IsOK(ecode2)) {
14254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14255 }
14256 arg2 = static_cast< int >(val2);
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 (arg1)->SetMovementThreshold(arg2);
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 resultobj = SWIG_Py_Void();
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14271 PyObject *resultobj = 0;
14272 wxJoystick *arg1 = (wxJoystick *) 0 ;
14273 bool result;
14274 void *argp1 = 0 ;
14275 int res1 = 0 ;
14276 PyObject *swig_obj[1] ;
14277
14278 if (!args) SWIG_fail;
14279 swig_obj[0] = args;
14280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14281 if (!SWIG_IsOK(res1)) {
14282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14283 }
14284 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14285 {
14286 PyThreadState* __tstate = wxPyBeginAllowThreads();
14287 result = (bool)(arg1)->IsOk();
14288 wxPyEndAllowThreads(__tstate);
14289 if (PyErr_Occurred()) SWIG_fail;
14290 }
14291 {
14292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14293 }
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14301 PyObject *resultobj = 0;
14302 wxJoystick *arg1 = (wxJoystick *) 0 ;
14303 int result;
14304 void *argp1 = 0 ;
14305 int res1 = 0 ;
14306 PyObject *swig_obj[1] ;
14307
14308 if (!args) SWIG_fail;
14309 swig_obj[0] = args;
14310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14311 if (!SWIG_IsOK(res1)) {
14312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14313 }
14314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = (int)(arg1)->GetNumberJoysticks();
14318 wxPyEndAllowThreads(__tstate);
14319 if (PyErr_Occurred()) SWIG_fail;
14320 }
14321 resultobj = SWIG_From_int(static_cast< int >(result));
14322 return resultobj;
14323 fail:
14324 return NULL;
14325 }
14326
14327
14328 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14329 PyObject *resultobj = 0;
14330 wxJoystick *arg1 = (wxJoystick *) 0 ;
14331 int result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 PyObject *swig_obj[1] ;
14335
14336 if (!args) SWIG_fail;
14337 swig_obj[0] = args;
14338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14341 }
14342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (int)(arg1)->GetManufacturerId();
14346 wxPyEndAllowThreads(__tstate);
14347 if (PyErr_Occurred()) SWIG_fail;
14348 }
14349 resultobj = SWIG_From_int(static_cast< int >(result));
14350 return resultobj;
14351 fail:
14352 return NULL;
14353 }
14354
14355
14356 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14357 PyObject *resultobj = 0;
14358 wxJoystick *arg1 = (wxJoystick *) 0 ;
14359 int result;
14360 void *argp1 = 0 ;
14361 int res1 = 0 ;
14362 PyObject *swig_obj[1] ;
14363
14364 if (!args) SWIG_fail;
14365 swig_obj[0] = args;
14366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14369 }
14370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (int)(arg1)->GetProductId();
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 resultobj = SWIG_From_int(static_cast< int >(result));
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14385 PyObject *resultobj = 0;
14386 wxJoystick *arg1 = (wxJoystick *) 0 ;
14387 wxString result;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 PyObject *swig_obj[1] ;
14391
14392 if (!args) SWIG_fail;
14393 swig_obj[0] = args;
14394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14395 if (!SWIG_IsOK(res1)) {
14396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14397 }
14398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 result = (arg1)->GetProductName();
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 {
14406 #if wxUSE_UNICODE
14407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14408 #else
14409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14410 #endif
14411 }
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxJoystick *arg1 = (wxJoystick *) 0 ;
14421 int result;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject *swig_obj[1] ;
14425
14426 if (!args) SWIG_fail;
14427 swig_obj[0] = args;
14428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14431 }
14432 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 result = (int)(arg1)->GetXMin();
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_From_int(static_cast< int >(result));
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447 PyObject *resultobj = 0;
14448 wxJoystick *arg1 = (wxJoystick *) 0 ;
14449 int result;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 PyObject *swig_obj[1] ;
14453
14454 if (!args) SWIG_fail;
14455 swig_obj[0] = args;
14456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14457 if (!SWIG_IsOK(res1)) {
14458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14459 }
14460 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (int)(arg1)->GetYMin();
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = SWIG_From_int(static_cast< int >(result));
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14475 PyObject *resultobj = 0;
14476 wxJoystick *arg1 = (wxJoystick *) 0 ;
14477 int result;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 PyObject *swig_obj[1] ;
14481
14482 if (!args) SWIG_fail;
14483 swig_obj[0] = args;
14484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14485 if (!SWIG_IsOK(res1)) {
14486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14487 }
14488 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (int)(arg1)->GetZMin();
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_From_int(static_cast< int >(result));
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14503 PyObject *resultobj = 0;
14504 wxJoystick *arg1 = (wxJoystick *) 0 ;
14505 int result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 PyObject *swig_obj[1] ;
14509
14510 if (!args) SWIG_fail;
14511 swig_obj[0] = args;
14512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14515 }
14516 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (int)(arg1)->GetXMax();
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = SWIG_From_int(static_cast< int >(result));
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14531 PyObject *resultobj = 0;
14532 wxJoystick *arg1 = (wxJoystick *) 0 ;
14533 int result;
14534 void *argp1 = 0 ;
14535 int res1 = 0 ;
14536 PyObject *swig_obj[1] ;
14537
14538 if (!args) SWIG_fail;
14539 swig_obj[0] = args;
14540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14543 }
14544 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (int)(arg1)->GetYMax();
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_From_int(static_cast< int >(result));
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14559 PyObject *resultobj = 0;
14560 wxJoystick *arg1 = (wxJoystick *) 0 ;
14561 int result;
14562 void *argp1 = 0 ;
14563 int res1 = 0 ;
14564 PyObject *swig_obj[1] ;
14565
14566 if (!args) SWIG_fail;
14567 swig_obj[0] = args;
14568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14569 if (!SWIG_IsOK(res1)) {
14570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14571 }
14572 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (int)(arg1)->GetZMax();
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 resultobj = SWIG_From_int(static_cast< int >(result));
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14587 PyObject *resultobj = 0;
14588 wxJoystick *arg1 = (wxJoystick *) 0 ;
14589 int result;
14590 void *argp1 = 0 ;
14591 int res1 = 0 ;
14592 PyObject *swig_obj[1] ;
14593
14594 if (!args) SWIG_fail;
14595 swig_obj[0] = args;
14596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14597 if (!SWIG_IsOK(res1)) {
14598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14599 }
14600 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14601 {
14602 PyThreadState* __tstate = wxPyBeginAllowThreads();
14603 result = (int)(arg1)->GetNumberButtons();
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = SWIG_From_int(static_cast< int >(result));
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14615 PyObject *resultobj = 0;
14616 wxJoystick *arg1 = (wxJoystick *) 0 ;
14617 int result;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 PyObject *swig_obj[1] ;
14621
14622 if (!args) SWIG_fail;
14623 swig_obj[0] = args;
14624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14625 if (!SWIG_IsOK(res1)) {
14626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14627 }
14628 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (int)(arg1)->GetNumberAxes();
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_From_int(static_cast< int >(result));
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14643 PyObject *resultobj = 0;
14644 wxJoystick *arg1 = (wxJoystick *) 0 ;
14645 int result;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 PyObject *swig_obj[1] ;
14649
14650 if (!args) SWIG_fail;
14651 swig_obj[0] = args;
14652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14653 if (!SWIG_IsOK(res1)) {
14654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14655 }
14656 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (int)(arg1)->GetMaxButtons();
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 resultobj = SWIG_From_int(static_cast< int >(result));
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14671 PyObject *resultobj = 0;
14672 wxJoystick *arg1 = (wxJoystick *) 0 ;
14673 int result;
14674 void *argp1 = 0 ;
14675 int res1 = 0 ;
14676 PyObject *swig_obj[1] ;
14677
14678 if (!args) SWIG_fail;
14679 swig_obj[0] = args;
14680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14681 if (!SWIG_IsOK(res1)) {
14682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14683 }
14684 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14685 {
14686 PyThreadState* __tstate = wxPyBeginAllowThreads();
14687 result = (int)(arg1)->GetMaxAxes();
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 resultobj = SWIG_From_int(static_cast< int >(result));
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14699 PyObject *resultobj = 0;
14700 wxJoystick *arg1 = (wxJoystick *) 0 ;
14701 int result;
14702 void *argp1 = 0 ;
14703 int res1 = 0 ;
14704 PyObject *swig_obj[1] ;
14705
14706 if (!args) SWIG_fail;
14707 swig_obj[0] = args;
14708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14709 if (!SWIG_IsOK(res1)) {
14710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14711 }
14712 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 result = (int)(arg1)->GetPollingMin();
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 resultobj = SWIG_From_int(static_cast< int >(result));
14720 return resultobj;
14721 fail:
14722 return NULL;
14723 }
14724
14725
14726 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14727 PyObject *resultobj = 0;
14728 wxJoystick *arg1 = (wxJoystick *) 0 ;
14729 int result;
14730 void *argp1 = 0 ;
14731 int res1 = 0 ;
14732 PyObject *swig_obj[1] ;
14733
14734 if (!args) SWIG_fail;
14735 swig_obj[0] = args;
14736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14737 if (!SWIG_IsOK(res1)) {
14738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14739 }
14740 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (int)(arg1)->GetPollingMax();
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 resultobj = SWIG_From_int(static_cast< int >(result));
14748 return resultobj;
14749 fail:
14750 return NULL;
14751 }
14752
14753
14754 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14755 PyObject *resultobj = 0;
14756 wxJoystick *arg1 = (wxJoystick *) 0 ;
14757 int result;
14758 void *argp1 = 0 ;
14759 int res1 = 0 ;
14760 PyObject *swig_obj[1] ;
14761
14762 if (!args) SWIG_fail;
14763 swig_obj[0] = args;
14764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14765 if (!SWIG_IsOK(res1)) {
14766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14767 }
14768 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 result = (int)(arg1)->GetRudderMin();
14772 wxPyEndAllowThreads(__tstate);
14773 if (PyErr_Occurred()) SWIG_fail;
14774 }
14775 resultobj = SWIG_From_int(static_cast< int >(result));
14776 return resultobj;
14777 fail:
14778 return NULL;
14779 }
14780
14781
14782 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14783 PyObject *resultobj = 0;
14784 wxJoystick *arg1 = (wxJoystick *) 0 ;
14785 int result;
14786 void *argp1 = 0 ;
14787 int res1 = 0 ;
14788 PyObject *swig_obj[1] ;
14789
14790 if (!args) SWIG_fail;
14791 swig_obj[0] = args;
14792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14793 if (!SWIG_IsOK(res1)) {
14794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14795 }
14796 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (int)(arg1)->GetRudderMax();
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 resultobj = SWIG_From_int(static_cast< int >(result));
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14811 PyObject *resultobj = 0;
14812 wxJoystick *arg1 = (wxJoystick *) 0 ;
14813 int result;
14814 void *argp1 = 0 ;
14815 int res1 = 0 ;
14816 PyObject *swig_obj[1] ;
14817
14818 if (!args) SWIG_fail;
14819 swig_obj[0] = args;
14820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14821 if (!SWIG_IsOK(res1)) {
14822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14823 }
14824 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 result = (int)(arg1)->GetUMin();
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 resultobj = SWIG_From_int(static_cast< int >(result));
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14839 PyObject *resultobj = 0;
14840 wxJoystick *arg1 = (wxJoystick *) 0 ;
14841 int result;
14842 void *argp1 = 0 ;
14843 int res1 = 0 ;
14844 PyObject *swig_obj[1] ;
14845
14846 if (!args) SWIG_fail;
14847 swig_obj[0] = args;
14848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14849 if (!SWIG_IsOK(res1)) {
14850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14851 }
14852 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 result = (int)(arg1)->GetUMax();
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 resultobj = SWIG_From_int(static_cast< int >(result));
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *resultobj = 0;
14868 wxJoystick *arg1 = (wxJoystick *) 0 ;
14869 int result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 PyObject *swig_obj[1] ;
14873
14874 if (!args) SWIG_fail;
14875 swig_obj[0] = args;
14876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14877 if (!SWIG_IsOK(res1)) {
14878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14879 }
14880 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (int)(arg1)->GetVMin();
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 resultobj = SWIG_From_int(static_cast< int >(result));
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14895 PyObject *resultobj = 0;
14896 wxJoystick *arg1 = (wxJoystick *) 0 ;
14897 int result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 PyObject *swig_obj[1] ;
14901
14902 if (!args) SWIG_fail;
14903 swig_obj[0] = args;
14904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14905 if (!SWIG_IsOK(res1)) {
14906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14907 }
14908 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (int)(arg1)->GetVMax();
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 resultobj = SWIG_From_int(static_cast< int >(result));
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14923 PyObject *resultobj = 0;
14924 wxJoystick *arg1 = (wxJoystick *) 0 ;
14925 bool result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 PyObject *swig_obj[1] ;
14929
14930 if (!args) SWIG_fail;
14931 swig_obj[0] = args;
14932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14935 }
14936 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 result = (bool)(arg1)->HasRudder();
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 {
14944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14945 }
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14953 PyObject *resultobj = 0;
14954 wxJoystick *arg1 = (wxJoystick *) 0 ;
14955 bool result;
14956 void *argp1 = 0 ;
14957 int res1 = 0 ;
14958 PyObject *swig_obj[1] ;
14959
14960 if (!args) SWIG_fail;
14961 swig_obj[0] = args;
14962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14963 if (!SWIG_IsOK(res1)) {
14964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14965 }
14966 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14967 {
14968 PyThreadState* __tstate = wxPyBeginAllowThreads();
14969 result = (bool)(arg1)->HasZ();
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 {
14974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14975 }
14976 return resultobj;
14977 fail:
14978 return NULL;
14979 }
14980
14981
14982 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14983 PyObject *resultobj = 0;
14984 wxJoystick *arg1 = (wxJoystick *) 0 ;
14985 bool result;
14986 void *argp1 = 0 ;
14987 int res1 = 0 ;
14988 PyObject *swig_obj[1] ;
14989
14990 if (!args) SWIG_fail;
14991 swig_obj[0] = args;
14992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14993 if (!SWIG_IsOK(res1)) {
14994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14995 }
14996 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14997 {
14998 PyThreadState* __tstate = wxPyBeginAllowThreads();
14999 result = (bool)(arg1)->HasU();
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 {
15004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15005 }
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxJoystick *arg1 = (wxJoystick *) 0 ;
15015 bool result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15025 }
15026 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (bool)(arg1)->HasV();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 {
15034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15035 }
15036 return resultobj;
15037 fail:
15038 return NULL;
15039 }
15040
15041
15042 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15043 PyObject *resultobj = 0;
15044 wxJoystick *arg1 = (wxJoystick *) 0 ;
15045 bool result;
15046 void *argp1 = 0 ;
15047 int res1 = 0 ;
15048 PyObject *swig_obj[1] ;
15049
15050 if (!args) SWIG_fail;
15051 swig_obj[0] = args;
15052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15053 if (!SWIG_IsOK(res1)) {
15054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15055 }
15056 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 result = (bool)(arg1)->HasPOV();
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 {
15064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15065 }
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15073 PyObject *resultobj = 0;
15074 wxJoystick *arg1 = (wxJoystick *) 0 ;
15075 bool result;
15076 void *argp1 = 0 ;
15077 int res1 = 0 ;
15078 PyObject *swig_obj[1] ;
15079
15080 if (!args) SWIG_fail;
15081 swig_obj[0] = args;
15082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15083 if (!SWIG_IsOK(res1)) {
15084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15085 }
15086 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15087 {
15088 PyThreadState* __tstate = wxPyBeginAllowThreads();
15089 result = (bool)(arg1)->HasPOV4Dir();
15090 wxPyEndAllowThreads(__tstate);
15091 if (PyErr_Occurred()) SWIG_fail;
15092 }
15093 {
15094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15095 }
15096 return resultobj;
15097 fail:
15098 return NULL;
15099 }
15100
15101
15102 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15103 PyObject *resultobj = 0;
15104 wxJoystick *arg1 = (wxJoystick *) 0 ;
15105 bool result;
15106 void *argp1 = 0 ;
15107 int res1 = 0 ;
15108 PyObject *swig_obj[1] ;
15109
15110 if (!args) SWIG_fail;
15111 swig_obj[0] = args;
15112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15113 if (!SWIG_IsOK(res1)) {
15114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15115 }
15116 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 result = (bool)(arg1)->HasPOVCTS();
15120 wxPyEndAllowThreads(__tstate);
15121 if (PyErr_Occurred()) SWIG_fail;
15122 }
15123 {
15124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15125 }
15126 return resultobj;
15127 fail:
15128 return NULL;
15129 }
15130
15131
15132 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj = 0;
15134 wxJoystick *arg1 = (wxJoystick *) 0 ;
15135 wxWindow *arg2 = (wxWindow *) 0 ;
15136 int arg3 = (int) 0 ;
15137 bool result;
15138 void *argp1 = 0 ;
15139 int res1 = 0 ;
15140 void *argp2 = 0 ;
15141 int res2 = 0 ;
15142 int val3 ;
15143 int ecode3 = 0 ;
15144 PyObject * obj0 = 0 ;
15145 PyObject * obj1 = 0 ;
15146 PyObject * obj2 = 0 ;
15147 char * kwnames[] = {
15148 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15149 };
15150
15151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15155 }
15156 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15158 if (!SWIG_IsOK(res2)) {
15159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15160 }
15161 arg2 = reinterpret_cast< wxWindow * >(argp2);
15162 if (obj2) {
15163 ecode3 = SWIG_AsVal_int(obj2, &val3);
15164 if (!SWIG_IsOK(ecode3)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15166 }
15167 arg3 = static_cast< int >(val3);
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (bool)(arg1)->SetCapture(arg2,arg3);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 {
15176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15177 }
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15185 PyObject *resultobj = 0;
15186 wxJoystick *arg1 = (wxJoystick *) 0 ;
15187 bool result;
15188 void *argp1 = 0 ;
15189 int res1 = 0 ;
15190 PyObject *swig_obj[1] ;
15191
15192 if (!args) SWIG_fail;
15193 swig_obj[0] = args;
15194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15195 if (!SWIG_IsOK(res1)) {
15196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15197 }
15198 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (bool)(arg1)->ReleaseCapture();
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15207 }
15208 return resultobj;
15209 fail:
15210 return NULL;
15211 }
15212
15213
15214 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15215 PyObject *obj;
15216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15217 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15218 return SWIG_Py_Void();
15219 }
15220
15221 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15222 return SWIG_Python_InitShadowInstance(args);
15223 }
15224
15225 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj = 0;
15227 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15228 int arg2 = (int) 0 ;
15229 int arg3 = (int) wxJOYSTICK1 ;
15230 int arg4 = (int) 0 ;
15231 wxJoystickEvent *result = 0 ;
15232 int val1 ;
15233 int ecode1 = 0 ;
15234 int val2 ;
15235 int ecode2 = 0 ;
15236 int val3 ;
15237 int ecode3 = 0 ;
15238 int val4 ;
15239 int ecode4 = 0 ;
15240 PyObject * obj0 = 0 ;
15241 PyObject * obj1 = 0 ;
15242 PyObject * obj2 = 0 ;
15243 PyObject * obj3 = 0 ;
15244 char * kwnames[] = {
15245 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15246 };
15247
15248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15249 if (obj0) {
15250 ecode1 = SWIG_AsVal_int(obj0, &val1);
15251 if (!SWIG_IsOK(ecode1)) {
15252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15253 }
15254 arg1 = static_cast< wxEventType >(val1);
15255 }
15256 if (obj1) {
15257 ecode2 = SWIG_AsVal_int(obj1, &val2);
15258 if (!SWIG_IsOK(ecode2)) {
15259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15260 }
15261 arg2 = static_cast< int >(val2);
15262 }
15263 if (obj2) {
15264 ecode3 = SWIG_AsVal_int(obj2, &val3);
15265 if (!SWIG_IsOK(ecode3)) {
15266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15267 }
15268 arg3 = static_cast< int >(val3);
15269 }
15270 if (obj3) {
15271 ecode4 = SWIG_AsVal_int(obj3, &val4);
15272 if (!SWIG_IsOK(ecode4)) {
15273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15274 }
15275 arg4 = static_cast< int >(val4);
15276 }
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15284 return resultobj;
15285 fail:
15286 return NULL;
15287 }
15288
15289
15290 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15291 PyObject *resultobj = 0;
15292 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15293 wxPoint result;
15294 void *argp1 = 0 ;
15295 int res1 = 0 ;
15296 PyObject *swig_obj[1] ;
15297
15298 if (!args) SWIG_fail;
15299 swig_obj[0] = args;
15300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15301 if (!SWIG_IsOK(res1)) {
15302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15303 }
15304 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15319 PyObject *resultobj = 0;
15320 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15321 int result;
15322 void *argp1 = 0 ;
15323 int res1 = 0 ;
15324 PyObject *swig_obj[1] ;
15325
15326 if (!args) SWIG_fail;
15327 swig_obj[0] = args;
15328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15331 }
15332 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 resultobj = SWIG_From_int(static_cast< int >(result));
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15349 int result;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15359 }
15360 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = SWIG_From_int(static_cast< int >(result));
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15375 PyObject *resultobj = 0;
15376 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15377 int result;
15378 void *argp1 = 0 ;
15379 int res1 = 0 ;
15380 PyObject *swig_obj[1] ;
15381
15382 if (!args) SWIG_fail;
15383 swig_obj[0] = args;
15384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15385 if (!SWIG_IsOK(res1)) {
15386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15387 }
15388 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 resultobj = SWIG_From_int(static_cast< int >(result));
15396 return resultobj;
15397 fail:
15398 return NULL;
15399 }
15400
15401
15402 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15403 PyObject *resultobj = 0;
15404 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15405 int result;
15406 void *argp1 = 0 ;
15407 int res1 = 0 ;
15408 PyObject *swig_obj[1] ;
15409
15410 if (!args) SWIG_fail;
15411 swig_obj[0] = args;
15412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15413 if (!SWIG_IsOK(res1)) {
15414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15415 }
15416 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15417 {
15418 PyThreadState* __tstate = wxPyBeginAllowThreads();
15419 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15420 wxPyEndAllowThreads(__tstate);
15421 if (PyErr_Occurred()) SWIG_fail;
15422 }
15423 resultobj = SWIG_From_int(static_cast< int >(result));
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj = 0;
15432 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15433 int arg2 ;
15434 void *argp1 = 0 ;
15435 int res1 = 0 ;
15436 int val2 ;
15437 int ecode2 = 0 ;
15438 PyObject * obj0 = 0 ;
15439 PyObject * obj1 = 0 ;
15440 char * kwnames[] = {
15441 (char *) "self",(char *) "stick", NULL
15442 };
15443
15444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15446 if (!SWIG_IsOK(res1)) {
15447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15448 }
15449 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15450 ecode2 = SWIG_AsVal_int(obj1, &val2);
15451 if (!SWIG_IsOK(ecode2)) {
15452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15453 }
15454 arg2 = static_cast< int >(val2);
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 (arg1)->SetJoystick(arg2);
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 resultobj = SWIG_Py_Void();
15462 return resultobj;
15463 fail:
15464 return NULL;
15465 }
15466
15467
15468 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15469 PyObject *resultobj = 0;
15470 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15471 int arg2 ;
15472 void *argp1 = 0 ;
15473 int res1 = 0 ;
15474 int val2 ;
15475 int ecode2 = 0 ;
15476 PyObject * obj0 = 0 ;
15477 PyObject * obj1 = 0 ;
15478 char * kwnames[] = {
15479 (char *) "self",(char *) "state", NULL
15480 };
15481
15482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15484 if (!SWIG_IsOK(res1)) {
15485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15486 }
15487 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15488 ecode2 = SWIG_AsVal_int(obj1, &val2);
15489 if (!SWIG_IsOK(ecode2)) {
15490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15491 }
15492 arg2 = static_cast< int >(val2);
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 (arg1)->SetButtonState(arg2);
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 resultobj = SWIG_Py_Void();
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15507 PyObject *resultobj = 0;
15508 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15509 int arg2 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 int val2 ;
15513 int ecode2 = 0 ;
15514 PyObject * obj0 = 0 ;
15515 PyObject * obj1 = 0 ;
15516 char * kwnames[] = {
15517 (char *) "self",(char *) "change", NULL
15518 };
15519
15520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15522 if (!SWIG_IsOK(res1)) {
15523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15524 }
15525 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15526 ecode2 = SWIG_AsVal_int(obj1, &val2);
15527 if (!SWIG_IsOK(ecode2)) {
15528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15529 }
15530 arg2 = static_cast< int >(val2);
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 (arg1)->SetButtonChange(arg2);
15534 wxPyEndAllowThreads(__tstate);
15535 if (PyErr_Occurred()) SWIG_fail;
15536 }
15537 resultobj = SWIG_Py_Void();
15538 return resultobj;
15539 fail:
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15545 PyObject *resultobj = 0;
15546 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15547 wxPoint *arg2 = 0 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 wxPoint temp2 ;
15551 PyObject * obj0 = 0 ;
15552 PyObject * obj1 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "pos", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15561 }
15562 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15563 {
15564 arg2 = &temp2;
15565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15566 }
15567 {
15568 PyThreadState* __tstate = wxPyBeginAllowThreads();
15569 (arg1)->SetPosition((wxPoint const &)*arg2);
15570 wxPyEndAllowThreads(__tstate);
15571 if (PyErr_Occurred()) SWIG_fail;
15572 }
15573 resultobj = SWIG_Py_Void();
15574 return resultobj;
15575 fail:
15576 return NULL;
15577 }
15578
15579
15580 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15581 PyObject *resultobj = 0;
15582 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15583 int arg2 ;
15584 void *argp1 = 0 ;
15585 int res1 = 0 ;
15586 int val2 ;
15587 int ecode2 = 0 ;
15588 PyObject * obj0 = 0 ;
15589 PyObject * obj1 = 0 ;
15590 char * kwnames[] = {
15591 (char *) "self",(char *) "zPos", NULL
15592 };
15593
15594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15598 }
15599 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15600 ecode2 = SWIG_AsVal_int(obj1, &val2);
15601 if (!SWIG_IsOK(ecode2)) {
15602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15603 }
15604 arg2 = static_cast< int >(val2);
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 (arg1)->SetZPosition(arg2);
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 resultobj = SWIG_Py_Void();
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15619 PyObject *resultobj = 0;
15620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15621 bool result;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 PyObject *swig_obj[1] ;
15625
15626 if (!args) SWIG_fail;
15627 swig_obj[0] = args;
15628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15629 if (!SWIG_IsOK(res1)) {
15630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15631 }
15632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15649 PyObject *resultobj = 0;
15650 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15651 bool result;
15652 void *argp1 = 0 ;
15653 int res1 = 0 ;
15654 PyObject *swig_obj[1] ;
15655
15656 if (!args) SWIG_fail;
15657 swig_obj[0] = args;
15658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15661 }
15662 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15679 PyObject *resultobj = 0;
15680 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15681 bool result;
15682 void *argp1 = 0 ;
15683 int res1 = 0 ;
15684 PyObject *swig_obj[1] ;
15685
15686 if (!args) SWIG_fail;
15687 swig_obj[0] = args;
15688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15689 if (!SWIG_IsOK(res1)) {
15690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15691 }
15692 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 {
15700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15701 }
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj = 0;
15710 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15711 int arg2 = (int) wxJOY_BUTTON_ANY ;
15712 bool result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 int val2 ;
15716 int ecode2 = 0 ;
15717 PyObject * obj0 = 0 ;
15718 PyObject * obj1 = 0 ;
15719 char * kwnames[] = {
15720 (char *) "self",(char *) "but", NULL
15721 };
15722
15723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15725 if (!SWIG_IsOK(res1)) {
15726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15727 }
15728 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15729 if (obj1) {
15730 ecode2 = SWIG_AsVal_int(obj1, &val2);
15731 if (!SWIG_IsOK(ecode2)) {
15732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15733 }
15734 arg2 = static_cast< int >(val2);
15735 }
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15739 wxPyEndAllowThreads(__tstate);
15740 if (PyErr_Occurred()) SWIG_fail;
15741 }
15742 {
15743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15744 }
15745 return resultobj;
15746 fail:
15747 return NULL;
15748 }
15749
15750
15751 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15752 PyObject *resultobj = 0;
15753 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15754 int arg2 = (int) wxJOY_BUTTON_ANY ;
15755 bool result;
15756 void *argp1 = 0 ;
15757 int res1 = 0 ;
15758 int val2 ;
15759 int ecode2 = 0 ;
15760 PyObject * obj0 = 0 ;
15761 PyObject * obj1 = 0 ;
15762 char * kwnames[] = {
15763 (char *) "self",(char *) "but", NULL
15764 };
15765
15766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15770 }
15771 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15772 if (obj1) {
15773 ecode2 = SWIG_AsVal_int(obj1, &val2);
15774 if (!SWIG_IsOK(ecode2)) {
15775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15776 }
15777 arg2 = static_cast< int >(val2);
15778 }
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 {
15786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15787 }
15788 return resultobj;
15789 fail:
15790 return NULL;
15791 }
15792
15793
15794 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15795 PyObject *resultobj = 0;
15796 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15797 int arg2 = (int) wxJOY_BUTTON_ANY ;
15798 bool result;
15799 void *argp1 = 0 ;
15800 int res1 = 0 ;
15801 int val2 ;
15802 int ecode2 = 0 ;
15803 PyObject * obj0 = 0 ;
15804 PyObject * obj1 = 0 ;
15805 char * kwnames[] = {
15806 (char *) "self",(char *) "but", NULL
15807 };
15808
15809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15813 }
15814 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15815 if (obj1) {
15816 ecode2 = SWIG_AsVal_int(obj1, &val2);
15817 if (!SWIG_IsOK(ecode2)) {
15818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15819 }
15820 arg2 = static_cast< int >(val2);
15821 }
15822 {
15823 PyThreadState* __tstate = wxPyBeginAllowThreads();
15824 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15825 wxPyEndAllowThreads(__tstate);
15826 if (PyErr_Occurred()) SWIG_fail;
15827 }
15828 {
15829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15830 }
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15838 PyObject *obj;
15839 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15840 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15841 return SWIG_Py_Void();
15842 }
15843
15844 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15845 return SWIG_Python_InitShadowInstance(args);
15846 }
15847
15848 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 wxString const &arg1_defvalue = wxPyEmptyString ;
15851 wxString *arg1 = (wxString *) &arg1_defvalue ;
15852 wxSound *result = 0 ;
15853 bool temp1 = false ;
15854 PyObject * obj0 = 0 ;
15855 char * kwnames[] = {
15856 (char *) "fileName", NULL
15857 };
15858
15859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15860 if (obj0) {
15861 {
15862 arg1 = wxString_in_helper(obj0);
15863 if (arg1 == NULL) SWIG_fail;
15864 temp1 = true;
15865 }
15866 }
15867 {
15868 if (!wxPyCheckForApp()) SWIG_fail;
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15871 wxPyEndAllowThreads(__tstate);
15872 if (PyErr_Occurred()) SWIG_fail;
15873 }
15874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15875 {
15876 if (temp1)
15877 delete arg1;
15878 }
15879 return resultobj;
15880 fail:
15881 {
15882 if (temp1)
15883 delete arg1;
15884 }
15885 return NULL;
15886 }
15887
15888
15889 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15890 PyObject *resultobj = 0;
15891 PyObject *arg1 = (PyObject *) 0 ;
15892 wxSound *result = 0 ;
15893 PyObject * obj0 = 0 ;
15894 char * kwnames[] = {
15895 (char *) "data", NULL
15896 };
15897
15898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15899 arg1 = obj0;
15900 {
15901 if (!wxPyCheckForApp()) SWIG_fail;
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (wxSound *)new_wxSound(arg1);
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15915 PyObject *resultobj = 0;
15916 wxSound *arg1 = (wxSound *) 0 ;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15926 }
15927 arg1 = reinterpret_cast< wxSound * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 delete arg1;
15931
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_Py_Void();
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15943 PyObject *resultobj = 0;
15944 wxSound *arg1 = (wxSound *) 0 ;
15945 wxString *arg2 = 0 ;
15946 bool result;
15947 void *argp1 = 0 ;
15948 int res1 = 0 ;
15949 bool temp2 = false ;
15950 PyObject * obj0 = 0 ;
15951 PyObject * obj1 = 0 ;
15952 char * kwnames[] = {
15953 (char *) "self",(char *) "fileName", NULL
15954 };
15955
15956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15958 if (!SWIG_IsOK(res1)) {
15959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15960 }
15961 arg1 = reinterpret_cast< wxSound * >(argp1);
15962 {
15963 arg2 = wxString_in_helper(obj1);
15964 if (arg2 == NULL) SWIG_fail;
15965 temp2 = true;
15966 }
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 result = (bool)(arg1)->Create((wxString const &)*arg2);
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 {
15974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15975 }
15976 {
15977 if (temp2)
15978 delete arg2;
15979 }
15980 return resultobj;
15981 fail:
15982 {
15983 if (temp2)
15984 delete arg2;
15985 }
15986 return NULL;
15987 }
15988
15989
15990 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj = 0;
15992 wxSound *arg1 = (wxSound *) 0 ;
15993 PyObject *arg2 = (PyObject *) 0 ;
15994 bool result;
15995 void *argp1 = 0 ;
15996 int res1 = 0 ;
15997 PyObject * obj0 = 0 ;
15998 PyObject * obj1 = 0 ;
15999 char * kwnames[] = {
16000 (char *) "self",(char *) "data", NULL
16001 };
16002
16003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16005 if (!SWIG_IsOK(res1)) {
16006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16007 }
16008 arg1 = reinterpret_cast< wxSound * >(argp1);
16009 arg2 = obj1;
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 result = (bool)wxSound_CreateFromData(arg1,arg2);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 {
16017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16018 }
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxSound *arg1 = (wxSound *) 0 ;
16028 bool result;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16038 }
16039 arg1 = reinterpret_cast< wxSound * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (bool)(arg1)->IsOk();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 {
16047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16048 }
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj = 0;
16057 wxSound *arg1 = (wxSound *) 0 ;
16058 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16059 bool result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 unsigned int val2 ;
16063 int ecode2 = 0 ;
16064 PyObject * obj0 = 0 ;
16065 PyObject * obj1 = 0 ;
16066 char * kwnames[] = {
16067 (char *) "self",(char *) "flags", NULL
16068 };
16069
16070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16072 if (!SWIG_IsOK(res1)) {
16073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16074 }
16075 arg1 = reinterpret_cast< wxSound * >(argp1);
16076 if (obj1) {
16077 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16078 if (!SWIG_IsOK(ecode2)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16080 }
16081 arg2 = static_cast< unsigned int >(val2);
16082 }
16083 {
16084 if (!wxPyCheckForApp()) SWIG_fail;
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 result = (bool)((wxSound const *)arg1)->Play(arg2);
16087 wxPyEndAllowThreads(__tstate);
16088 if (PyErr_Occurred()) SWIG_fail;
16089 }
16090 {
16091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16092 }
16093 return resultobj;
16094 fail:
16095 return NULL;
16096 }
16097
16098
16099 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj = 0;
16101 wxString *arg1 = 0 ;
16102 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16103 bool result;
16104 bool temp1 = false ;
16105 unsigned int val2 ;
16106 int ecode2 = 0 ;
16107 PyObject * obj0 = 0 ;
16108 PyObject * obj1 = 0 ;
16109 char * kwnames[] = {
16110 (char *) "filename",(char *) "flags", NULL
16111 };
16112
16113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16114 {
16115 arg1 = wxString_in_helper(obj0);
16116 if (arg1 == NULL) SWIG_fail;
16117 temp1 = true;
16118 }
16119 if (obj1) {
16120 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16121 if (!SWIG_IsOK(ecode2)) {
16122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16123 }
16124 arg2 = static_cast< unsigned int >(val2);
16125 }
16126 {
16127 if (!wxPyCheckForApp()) SWIG_fail;
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 {
16134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16135 }
16136 {
16137 if (temp1)
16138 delete arg1;
16139 }
16140 return resultobj;
16141 fail:
16142 {
16143 if (temp1)
16144 delete arg1;
16145 }
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16151 PyObject *resultobj = 0;
16152
16153 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16154 {
16155 if (!wxPyCheckForApp()) SWIG_fail;
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 wxSound::Stop();
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 resultobj = SWIG_Py_Void();
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16169 PyObject *obj;
16170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16171 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16172 return SWIG_Py_Void();
16173 }
16174
16175 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16176 return SWIG_Python_InitShadowInstance(args);
16177 }
16178
16179 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj = 0;
16181 wxString *arg1 = 0 ;
16182 wxString *arg2 = 0 ;
16183 wxString *arg3 = 0 ;
16184 wxString *arg4 = 0 ;
16185 wxFileTypeInfo *result = 0 ;
16186 bool temp1 = false ;
16187 bool temp2 = false ;
16188 bool temp3 = false ;
16189 bool temp4 = false ;
16190 PyObject * obj0 = 0 ;
16191 PyObject * obj1 = 0 ;
16192 PyObject * obj2 = 0 ;
16193 PyObject * obj3 = 0 ;
16194 char * kwnames[] = {
16195 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16196 };
16197
16198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16199 {
16200 arg1 = wxString_in_helper(obj0);
16201 if (arg1 == NULL) SWIG_fail;
16202 temp1 = true;
16203 }
16204 {
16205 arg2 = wxString_in_helper(obj1);
16206 if (arg2 == NULL) SWIG_fail;
16207 temp2 = true;
16208 }
16209 {
16210 arg3 = wxString_in_helper(obj2);
16211 if (arg3 == NULL) SWIG_fail;
16212 temp3 = true;
16213 }
16214 {
16215 arg4 = wxString_in_helper(obj3);
16216 if (arg4 == NULL) SWIG_fail;
16217 temp4 = true;
16218 }
16219 {
16220 PyThreadState* __tstate = wxPyBeginAllowThreads();
16221 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16222 wxPyEndAllowThreads(__tstate);
16223 if (PyErr_Occurred()) SWIG_fail;
16224 }
16225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16226 {
16227 if (temp1)
16228 delete arg1;
16229 }
16230 {
16231 if (temp2)
16232 delete arg2;
16233 }
16234 {
16235 if (temp3)
16236 delete arg3;
16237 }
16238 {
16239 if (temp4)
16240 delete arg4;
16241 }
16242 return resultobj;
16243 fail:
16244 {
16245 if (temp1)
16246 delete arg1;
16247 }
16248 {
16249 if (temp2)
16250 delete arg2;
16251 }
16252 {
16253 if (temp3)
16254 delete arg3;
16255 }
16256 {
16257 if (temp4)
16258 delete arg4;
16259 }
16260 return NULL;
16261 }
16262
16263
16264 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16265 PyObject *resultobj = 0;
16266 wxArrayString *arg1 = 0 ;
16267 wxFileTypeInfo *result = 0 ;
16268 bool temp1 = false ;
16269 PyObject * obj0 = 0 ;
16270 char * kwnames[] = {
16271 (char *) "sArray", NULL
16272 };
16273
16274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16275 {
16276 if (! PySequence_Check(obj0)) {
16277 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16278 SWIG_fail;
16279 }
16280 arg1 = new wxArrayString;
16281 temp1 = true;
16282 int i, len=PySequence_Length(obj0);
16283 for (i=0; i<len; i++) {
16284 PyObject* item = PySequence_GetItem(obj0, i);
16285 wxString* s = wxString_in_helper(item);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 arg1->Add(*s);
16288 delete s;
16289 Py_DECREF(item);
16290 }
16291 }
16292 {
16293 PyThreadState* __tstate = wxPyBeginAllowThreads();
16294 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16299 {
16300 if (temp1) delete arg1;
16301 }
16302 return resultobj;
16303 fail:
16304 {
16305 if (temp1) delete arg1;
16306 }
16307 return NULL;
16308 }
16309
16310
16311 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16312 PyObject *resultobj = 0;
16313 wxFileTypeInfo *result = 0 ;
16314
16315 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16323 return resultobj;
16324 fail:
16325 return NULL;
16326 }
16327
16328
16329 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16330 PyObject *resultobj = 0;
16331 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16332 bool result;
16333 void *argp1 = 0 ;
16334 int res1 = 0 ;
16335 PyObject *swig_obj[1] ;
16336
16337 if (!args) SWIG_fail;
16338 swig_obj[0] = args;
16339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16340 if (!SWIG_IsOK(res1)) {
16341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16342 }
16343 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 {
16351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16352 }
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj = 0;
16361 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16362 wxString *arg2 = 0 ;
16363 int arg3 = (int) 0 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 bool temp2 = false ;
16367 int val3 ;
16368 int ecode3 = 0 ;
16369 PyObject * obj0 = 0 ;
16370 PyObject * obj1 = 0 ;
16371 PyObject * obj2 = 0 ;
16372 char * kwnames[] = {
16373 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16374 };
16375
16376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16378 if (!SWIG_IsOK(res1)) {
16379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16380 }
16381 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16382 {
16383 arg2 = wxString_in_helper(obj1);
16384 if (arg2 == NULL) SWIG_fail;
16385 temp2 = true;
16386 }
16387 if (obj2) {
16388 ecode3 = SWIG_AsVal_int(obj2, &val3);
16389 if (!SWIG_IsOK(ecode3)) {
16390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16391 }
16392 arg3 = static_cast< int >(val3);
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_Py_Void();
16401 {
16402 if (temp2)
16403 delete arg2;
16404 }
16405 return resultobj;
16406 fail:
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return NULL;
16412 }
16413
16414
16415 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj = 0;
16417 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16418 wxString *arg2 = 0 ;
16419 void *argp1 = 0 ;
16420 int res1 = 0 ;
16421 bool temp2 = false ;
16422 PyObject * obj0 = 0 ;
16423 PyObject * obj1 = 0 ;
16424 char * kwnames[] = {
16425 (char *) "self",(char *) "shortDesc", NULL
16426 };
16427
16428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16430 if (!SWIG_IsOK(res1)) {
16431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16432 }
16433 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16434 {
16435 arg2 = wxString_in_helper(obj1);
16436 if (arg2 == NULL) SWIG_fail;
16437 temp2 = true;
16438 }
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 (arg1)->SetShortDesc((wxString const &)*arg2);
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_Py_Void();
16446 {
16447 if (temp2)
16448 delete arg2;
16449 }
16450 return resultobj;
16451 fail:
16452 {
16453 if (temp2)
16454 delete arg2;
16455 }
16456 return NULL;
16457 }
16458
16459
16460 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16461 PyObject *resultobj = 0;
16462 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16463 wxString *result = 0 ;
16464 void *argp1 = 0 ;
16465 int res1 = 0 ;
16466 PyObject *swig_obj[1] ;
16467
16468 if (!args) SWIG_fail;
16469 swig_obj[0] = args;
16470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16471 if (!SWIG_IsOK(res1)) {
16472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16473 }
16474 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 {
16478 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16479 result = (wxString *) &_result_ref;
16480 }
16481 wxPyEndAllowThreads(__tstate);
16482 if (PyErr_Occurred()) SWIG_fail;
16483 }
16484 {
16485 #if wxUSE_UNICODE
16486 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16487 #else
16488 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16489 #endif
16490 }
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16498 PyObject *resultobj = 0;
16499 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16500 wxString *result = 0 ;
16501 void *argp1 = 0 ;
16502 int res1 = 0 ;
16503 PyObject *swig_obj[1] ;
16504
16505 if (!args) SWIG_fail;
16506 swig_obj[0] = args;
16507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16508 if (!SWIG_IsOK(res1)) {
16509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16510 }
16511 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 {
16515 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16516 result = (wxString *) &_result_ref;
16517 }
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 {
16522 #if wxUSE_UNICODE
16523 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16524 #else
16525 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16526 #endif
16527 }
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16535 PyObject *resultobj = 0;
16536 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16537 wxString *result = 0 ;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 PyObject *swig_obj[1] ;
16541
16542 if (!args) SWIG_fail;
16543 swig_obj[0] = args;
16544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16545 if (!SWIG_IsOK(res1)) {
16546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16547 }
16548 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 {
16552 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16553 result = (wxString *) &_result_ref;
16554 }
16555 wxPyEndAllowThreads(__tstate);
16556 if (PyErr_Occurred()) SWIG_fail;
16557 }
16558 {
16559 #if wxUSE_UNICODE
16560 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16561 #else
16562 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16563 #endif
16564 }
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16572 PyObject *resultobj = 0;
16573 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16574 wxString *result = 0 ;
16575 void *argp1 = 0 ;
16576 int res1 = 0 ;
16577 PyObject *swig_obj[1] ;
16578
16579 if (!args) SWIG_fail;
16580 swig_obj[0] = args;
16581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16582 if (!SWIG_IsOK(res1)) {
16583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16584 }
16585 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16586 {
16587 PyThreadState* __tstate = wxPyBeginAllowThreads();
16588 {
16589 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16590 result = (wxString *) &_result_ref;
16591 }
16592 wxPyEndAllowThreads(__tstate);
16593 if (PyErr_Occurred()) SWIG_fail;
16594 }
16595 {
16596 #if wxUSE_UNICODE
16597 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16598 #else
16599 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16600 #endif
16601 }
16602 return resultobj;
16603 fail:
16604 return NULL;
16605 }
16606
16607
16608 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16609 PyObject *resultobj = 0;
16610 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16611 wxString *result = 0 ;
16612 void *argp1 = 0 ;
16613 int res1 = 0 ;
16614 PyObject *swig_obj[1] ;
16615
16616 if (!args) SWIG_fail;
16617 swig_obj[0] = args;
16618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16619 if (!SWIG_IsOK(res1)) {
16620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16621 }
16622 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 {
16626 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16627 result = (wxString *) &_result_ref;
16628 }
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 {
16633 #if wxUSE_UNICODE
16634 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16635 #else
16636 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16637 #endif
16638 }
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16646 PyObject *resultobj = 0;
16647 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16648 wxArrayString *result = 0 ;
16649 void *argp1 = 0 ;
16650 int res1 = 0 ;
16651 PyObject *swig_obj[1] ;
16652
16653 if (!args) SWIG_fail;
16654 swig_obj[0] = args;
16655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16658 }
16659 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 {
16663 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16664 result = (wxArrayString *) &_result_ref;
16665 }
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 {
16670 resultobj = wxArrayString2PyList_helper(*result);
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16679 PyObject *resultobj = 0;
16680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16681 size_t result;
16682 void *argp1 = 0 ;
16683 int res1 = 0 ;
16684 PyObject *swig_obj[1] ;
16685
16686 if (!args) SWIG_fail;
16687 swig_obj[0] = args;
16688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16689 if (!SWIG_IsOK(res1)) {
16690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16691 }
16692 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16693 {
16694 PyThreadState* __tstate = wxPyBeginAllowThreads();
16695 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16696 wxPyEndAllowThreads(__tstate);
16697 if (PyErr_Occurred()) SWIG_fail;
16698 }
16699 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16707 PyObject *resultobj = 0;
16708 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16709 wxString *result = 0 ;
16710 void *argp1 = 0 ;
16711 int res1 = 0 ;
16712 PyObject *swig_obj[1] ;
16713
16714 if (!args) SWIG_fail;
16715 swig_obj[0] = args;
16716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16717 if (!SWIG_IsOK(res1)) {
16718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16719 }
16720 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 {
16724 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16725 result = (wxString *) &_result_ref;
16726 }
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 {
16731 #if wxUSE_UNICODE
16732 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16733 #else
16734 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16735 #endif
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16744 PyObject *resultobj = 0;
16745 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16746 int result;
16747 void *argp1 = 0 ;
16748 int res1 = 0 ;
16749 PyObject *swig_obj[1] ;
16750
16751 if (!args) SWIG_fail;
16752 swig_obj[0] = args;
16753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16754 if (!SWIG_IsOK(res1)) {
16755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16756 }
16757 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 resultobj = SWIG_From_int(static_cast< int >(result));
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16772 PyObject *obj;
16773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16774 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16775 return SWIG_Py_Void();
16776 }
16777
16778 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16779 return SWIG_Python_InitShadowInstance(args);
16780 }
16781
16782 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj = 0;
16784 wxFileTypeInfo *arg1 = 0 ;
16785 wxFileType *result = 0 ;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 PyObject * obj0 = 0 ;
16789 char * kwnames[] = {
16790 (char *) "ftInfo", NULL
16791 };
16792
16793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16794 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16797 }
16798 if (!argp1) {
16799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16800 }
16801 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16816 PyObject *resultobj = 0;
16817 wxFileType *arg1 = (wxFileType *) 0 ;
16818 void *argp1 = 0 ;
16819 int res1 = 0 ;
16820 PyObject *swig_obj[1] ;
16821
16822 if (!args) SWIG_fail;
16823 swig_obj[0] = args;
16824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16825 if (!SWIG_IsOK(res1)) {
16826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16827 }
16828 arg1 = reinterpret_cast< wxFileType * >(argp1);
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 delete arg1;
16832
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 resultobj = SWIG_Py_Void();
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16844 PyObject *resultobj = 0;
16845 wxFileType *arg1 = (wxFileType *) 0 ;
16846 PyObject *result = 0 ;
16847 void *argp1 = 0 ;
16848 int res1 = 0 ;
16849 PyObject *swig_obj[1] ;
16850
16851 if (!args) SWIG_fail;
16852 swig_obj[0] = args;
16853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16856 }
16857 arg1 = reinterpret_cast< wxFileType * >(argp1);
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (PyObject *)wxFileType_GetMimeType(arg1);
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 resultobj = result;
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16872 PyObject *resultobj = 0;
16873 wxFileType *arg1 = (wxFileType *) 0 ;
16874 PyObject *result = 0 ;
16875 void *argp1 = 0 ;
16876 int res1 = 0 ;
16877 PyObject *swig_obj[1] ;
16878
16879 if (!args) SWIG_fail;
16880 swig_obj[0] = args;
16881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16882 if (!SWIG_IsOK(res1)) {
16883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16884 }
16885 arg1 = reinterpret_cast< wxFileType * >(argp1);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = result;
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16900 PyObject *resultobj = 0;
16901 wxFileType *arg1 = (wxFileType *) 0 ;
16902 PyObject *result = 0 ;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 PyObject *swig_obj[1] ;
16906
16907 if (!args) SWIG_fail;
16908 swig_obj[0] = args;
16909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16912 }
16913 arg1 = reinterpret_cast< wxFileType * >(argp1);
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (PyObject *)wxFileType_GetExtensions(arg1);
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 resultobj = result;
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16928 PyObject *resultobj = 0;
16929 wxFileType *arg1 = (wxFileType *) 0 ;
16930 wxIcon *result = 0 ;
16931 void *argp1 = 0 ;
16932 int res1 = 0 ;
16933 PyObject *swig_obj[1] ;
16934
16935 if (!args) SWIG_fail;
16936 swig_obj[0] = args;
16937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16938 if (!SWIG_IsOK(res1)) {
16939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16940 }
16941 arg1 = reinterpret_cast< wxFileType * >(argp1);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (wxIcon *)wxFileType_GetIcon(arg1);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16956 PyObject *resultobj = 0;
16957 wxFileType *arg1 = (wxFileType *) 0 ;
16958 PyObject *result = 0 ;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 PyObject *swig_obj[1] ;
16962
16963 if (!args) SWIG_fail;
16964 swig_obj[0] = args;
16965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16968 }
16969 arg1 = reinterpret_cast< wxFileType * >(argp1);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 resultobj = result;
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16984 PyObject *resultobj = 0;
16985 wxFileType *arg1 = (wxFileType *) 0 ;
16986 PyObject *result = 0 ;
16987 void *argp1 = 0 ;
16988 int res1 = 0 ;
16989 PyObject *swig_obj[1] ;
16990
16991 if (!args) SWIG_fail;
16992 swig_obj[0] = args;
16993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16994 if (!SWIG_IsOK(res1)) {
16995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16996 }
16997 arg1 = reinterpret_cast< wxFileType * >(argp1);
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (PyObject *)wxFileType_GetDescription(arg1);
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 resultobj = result;
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj = 0;
17013 wxFileType *arg1 = (wxFileType *) 0 ;
17014 wxString *arg2 = 0 ;
17015 wxString const &arg3_defvalue = wxPyEmptyString ;
17016 wxString *arg3 = (wxString *) &arg3_defvalue ;
17017 PyObject *result = 0 ;
17018 void *argp1 = 0 ;
17019 int res1 = 0 ;
17020 bool temp2 = false ;
17021 bool temp3 = false ;
17022 PyObject * obj0 = 0 ;
17023 PyObject * obj1 = 0 ;
17024 PyObject * obj2 = 0 ;
17025 char * kwnames[] = {
17026 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17027 };
17028
17029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17031 if (!SWIG_IsOK(res1)) {
17032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17033 }
17034 arg1 = reinterpret_cast< wxFileType * >(argp1);
17035 {
17036 arg2 = wxString_in_helper(obj1);
17037 if (arg2 == NULL) SWIG_fail;
17038 temp2 = true;
17039 }
17040 if (obj2) {
17041 {
17042 arg3 = wxString_in_helper(obj2);
17043 if (arg3 == NULL) SWIG_fail;
17044 temp3 = true;
17045 }
17046 }
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 resultobj = result;
17054 {
17055 if (temp2)
17056 delete arg2;
17057 }
17058 {
17059 if (temp3)
17060 delete arg3;
17061 }
17062 return resultobj;
17063 fail:
17064 {
17065 if (temp2)
17066 delete arg2;
17067 }
17068 {
17069 if (temp3)
17070 delete arg3;
17071 }
17072 return NULL;
17073 }
17074
17075
17076 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17077 PyObject *resultobj = 0;
17078 wxFileType *arg1 = (wxFileType *) 0 ;
17079 wxString *arg2 = 0 ;
17080 wxString const &arg3_defvalue = wxPyEmptyString ;
17081 wxString *arg3 = (wxString *) &arg3_defvalue ;
17082 PyObject *result = 0 ;
17083 void *argp1 = 0 ;
17084 int res1 = 0 ;
17085 bool temp2 = false ;
17086 bool temp3 = false ;
17087 PyObject * obj0 = 0 ;
17088 PyObject * obj1 = 0 ;
17089 PyObject * obj2 = 0 ;
17090 char * kwnames[] = {
17091 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17092 };
17093
17094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17096 if (!SWIG_IsOK(res1)) {
17097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17098 }
17099 arg1 = reinterpret_cast< wxFileType * >(argp1);
17100 {
17101 arg2 = wxString_in_helper(obj1);
17102 if (arg2 == NULL) SWIG_fail;
17103 temp2 = true;
17104 }
17105 if (obj2) {
17106 {
17107 arg3 = wxString_in_helper(obj2);
17108 if (arg3 == NULL) SWIG_fail;
17109 temp3 = true;
17110 }
17111 }
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17115 wxPyEndAllowThreads(__tstate);
17116 if (PyErr_Occurred()) SWIG_fail;
17117 }
17118 resultobj = result;
17119 {
17120 if (temp2)
17121 delete arg2;
17122 }
17123 {
17124 if (temp3)
17125 delete arg3;
17126 }
17127 return resultobj;
17128 fail:
17129 {
17130 if (temp2)
17131 delete arg2;
17132 }
17133 {
17134 if (temp3)
17135 delete arg3;
17136 }
17137 return NULL;
17138 }
17139
17140
17141 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17142 PyObject *resultobj = 0;
17143 wxFileType *arg1 = (wxFileType *) 0 ;
17144 wxString *arg2 = 0 ;
17145 wxString const &arg3_defvalue = wxPyEmptyString ;
17146 wxString *arg3 = (wxString *) &arg3_defvalue ;
17147 PyObject *result = 0 ;
17148 void *argp1 = 0 ;
17149 int res1 = 0 ;
17150 bool temp2 = false ;
17151 bool temp3 = false ;
17152 PyObject * obj0 = 0 ;
17153 PyObject * obj1 = 0 ;
17154 PyObject * obj2 = 0 ;
17155 char * kwnames[] = {
17156 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17157 };
17158
17159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17161 if (!SWIG_IsOK(res1)) {
17162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17163 }
17164 arg1 = reinterpret_cast< wxFileType * >(argp1);
17165 {
17166 arg2 = wxString_in_helper(obj1);
17167 if (arg2 == NULL) SWIG_fail;
17168 temp2 = true;
17169 }
17170 if (obj2) {
17171 {
17172 arg3 = wxString_in_helper(obj2);
17173 if (arg3 == NULL) SWIG_fail;
17174 temp3 = true;
17175 }
17176 }
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = result;
17184 {
17185 if (temp2)
17186 delete arg2;
17187 }
17188 {
17189 if (temp3)
17190 delete arg3;
17191 }
17192 return resultobj;
17193 fail:
17194 {
17195 if (temp2)
17196 delete arg2;
17197 }
17198 {
17199 if (temp3)
17200 delete arg3;
17201 }
17202 return NULL;
17203 }
17204
17205
17206 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17207 PyObject *resultobj = 0;
17208 wxFileType *arg1 = (wxFileType *) 0 ;
17209 wxString *arg2 = 0 ;
17210 wxString *arg3 = 0 ;
17211 bool arg4 = (bool) true ;
17212 bool result;
17213 void *argp1 = 0 ;
17214 int res1 = 0 ;
17215 bool temp2 = false ;
17216 bool temp3 = false ;
17217 bool val4 ;
17218 int ecode4 = 0 ;
17219 PyObject * obj0 = 0 ;
17220 PyObject * obj1 = 0 ;
17221 PyObject * obj2 = 0 ;
17222 PyObject * obj3 = 0 ;
17223 char * kwnames[] = {
17224 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17225 };
17226
17227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17229 if (!SWIG_IsOK(res1)) {
17230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17231 }
17232 arg1 = reinterpret_cast< wxFileType * >(argp1);
17233 {
17234 arg2 = wxString_in_helper(obj1);
17235 if (arg2 == NULL) SWIG_fail;
17236 temp2 = true;
17237 }
17238 {
17239 arg3 = wxString_in_helper(obj2);
17240 if (arg3 == NULL) SWIG_fail;
17241 temp3 = true;
17242 }
17243 if (obj3) {
17244 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17245 if (!SWIG_IsOK(ecode4)) {
17246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17247 }
17248 arg4 = static_cast< bool >(val4);
17249 }
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 {
17257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17258 }
17259 {
17260 if (temp2)
17261 delete arg2;
17262 }
17263 {
17264 if (temp3)
17265 delete arg3;
17266 }
17267 return resultobj;
17268 fail:
17269 {
17270 if (temp2)
17271 delete arg2;
17272 }
17273 {
17274 if (temp3)
17275 delete arg3;
17276 }
17277 return NULL;
17278 }
17279
17280
17281 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj = 0;
17283 wxFileType *arg1 = (wxFileType *) 0 ;
17284 wxString const &arg2_defvalue = wxPyEmptyString ;
17285 wxString *arg2 = (wxString *) &arg2_defvalue ;
17286 int arg3 = (int) 0 ;
17287 bool result;
17288 void *argp1 = 0 ;
17289 int res1 = 0 ;
17290 bool temp2 = false ;
17291 int val3 ;
17292 int ecode3 = 0 ;
17293 PyObject * obj0 = 0 ;
17294 PyObject * obj1 = 0 ;
17295 PyObject * obj2 = 0 ;
17296 char * kwnames[] = {
17297 (char *) "self",(char *) "cmd",(char *) "index", NULL
17298 };
17299
17300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17302 if (!SWIG_IsOK(res1)) {
17303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17304 }
17305 arg1 = reinterpret_cast< wxFileType * >(argp1);
17306 if (obj1) {
17307 {
17308 arg2 = wxString_in_helper(obj1);
17309 if (arg2 == NULL) SWIG_fail;
17310 temp2 = true;
17311 }
17312 }
17313 if (obj2) {
17314 ecode3 = SWIG_AsVal_int(obj2, &val3);
17315 if (!SWIG_IsOK(ecode3)) {
17316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17317 }
17318 arg3 = static_cast< int >(val3);
17319 }
17320 {
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 {
17330 if (temp2)
17331 delete arg2;
17332 }
17333 return resultobj;
17334 fail:
17335 {
17336 if (temp2)
17337 delete arg2;
17338 }
17339 return NULL;
17340 }
17341
17342
17343 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17344 PyObject *resultobj = 0;
17345 wxFileType *arg1 = (wxFileType *) 0 ;
17346 bool result;
17347 void *argp1 = 0 ;
17348 int res1 = 0 ;
17349 PyObject *swig_obj[1] ;
17350
17351 if (!args) SWIG_fail;
17352 swig_obj[0] = args;
17353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17354 if (!SWIG_IsOK(res1)) {
17355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17356 }
17357 arg1 = reinterpret_cast< wxFileType * >(argp1);
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 result = (bool)(arg1)->Unassociate();
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxString *arg1 = 0 ;
17376 wxString *arg2 = 0 ;
17377 wxString const &arg3_defvalue = wxPyEmptyString ;
17378 wxString *arg3 = (wxString *) &arg3_defvalue ;
17379 wxString result;
17380 bool temp1 = false ;
17381 bool temp2 = false ;
17382 bool temp3 = false ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 PyObject * obj2 = 0 ;
17386 char * kwnames[] = {
17387 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17388 };
17389
17390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17391 {
17392 arg1 = wxString_in_helper(obj0);
17393 if (arg1 == NULL) SWIG_fail;
17394 temp1 = true;
17395 }
17396 {
17397 arg2 = wxString_in_helper(obj1);
17398 if (arg2 == NULL) SWIG_fail;
17399 temp2 = true;
17400 }
17401 if (obj2) {
17402 {
17403 arg3 = wxString_in_helper(obj2);
17404 if (arg3 == NULL) SWIG_fail;
17405 temp3 = true;
17406 }
17407 }
17408 {
17409 PyThreadState* __tstate = wxPyBeginAllowThreads();
17410 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17411 wxPyEndAllowThreads(__tstate);
17412 if (PyErr_Occurred()) SWIG_fail;
17413 }
17414 {
17415 #if wxUSE_UNICODE
17416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17417 #else
17418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17419 #endif
17420 }
17421 {
17422 if (temp1)
17423 delete arg1;
17424 }
17425 {
17426 if (temp2)
17427 delete arg2;
17428 }
17429 {
17430 if (temp3)
17431 delete arg3;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp1)
17437 delete arg1;
17438 }
17439 {
17440 if (temp2)
17441 delete arg2;
17442 }
17443 {
17444 if (temp3)
17445 delete arg3;
17446 }
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *obj;
17453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17454 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17455 return SWIG_Py_Void();
17456 }
17457
17458 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 return SWIG_Python_InitShadowInstance(args);
17460 }
17461
17462 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17463 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17464 return 1;
17465 }
17466
17467
17468 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17469 PyObject *pyobj = 0;
17470
17471 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17472 return pyobj;
17473 }
17474
17475
17476 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17477 PyObject *resultobj = 0;
17478 wxString *arg1 = 0 ;
17479 wxString *arg2 = 0 ;
17480 bool result;
17481 bool temp1 = false ;
17482 bool temp2 = false ;
17483 PyObject * obj0 = 0 ;
17484 PyObject * obj1 = 0 ;
17485 char * kwnames[] = {
17486 (char *) "mimeType",(char *) "wildcard", NULL
17487 };
17488
17489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17490 {
17491 arg1 = wxString_in_helper(obj0);
17492 if (arg1 == NULL) SWIG_fail;
17493 temp1 = true;
17494 }
17495 {
17496 arg2 = wxString_in_helper(obj1);
17497 if (arg2 == NULL) SWIG_fail;
17498 temp2 = true;
17499 }
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17508 }
17509 {
17510 if (temp1)
17511 delete arg1;
17512 }
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp1)
17521 delete arg1;
17522 }
17523 {
17524 if (temp2)
17525 delete arg2;
17526 }
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxMimeTypesManager *result = 0 ;
17534
17535 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj = 0;
17551 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17552 int arg2 = (int) wxMAILCAP_ALL ;
17553 wxString const &arg3_defvalue = wxPyEmptyString ;
17554 wxString *arg3 = (wxString *) &arg3_defvalue ;
17555 void *argp1 = 0 ;
17556 int res1 = 0 ;
17557 int val2 ;
17558 int ecode2 = 0 ;
17559 bool temp3 = false ;
17560 PyObject * obj0 = 0 ;
17561 PyObject * obj1 = 0 ;
17562 PyObject * obj2 = 0 ;
17563 char * kwnames[] = {
17564 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17565 };
17566
17567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17569 if (!SWIG_IsOK(res1)) {
17570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17571 }
17572 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17573 if (obj1) {
17574 ecode2 = SWIG_AsVal_int(obj1, &val2);
17575 if (!SWIG_IsOK(ecode2)) {
17576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17577 }
17578 arg2 = static_cast< int >(val2);
17579 }
17580 if (obj2) {
17581 {
17582 arg3 = wxString_in_helper(obj2);
17583 if (arg3 == NULL) SWIG_fail;
17584 temp3 = true;
17585 }
17586 }
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 resultobj = SWIG_Py_Void();
17594 {
17595 if (temp3)
17596 delete arg3;
17597 }
17598 return resultobj;
17599 fail:
17600 {
17601 if (temp3)
17602 delete arg3;
17603 }
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 PyObject *resultobj = 0;
17610 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17611 void *argp1 = 0 ;
17612 int res1 = 0 ;
17613 PyObject *swig_obj[1] ;
17614
17615 if (!args) SWIG_fail;
17616 swig_obj[0] = args;
17617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17618 if (!SWIG_IsOK(res1)) {
17619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17620 }
17621 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 (arg1)->ClearData();
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 resultobj = SWIG_Py_Void();
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17636 PyObject *resultobj = 0;
17637 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17638 wxString *arg2 = 0 ;
17639 wxFileType *result = 0 ;
17640 void *argp1 = 0 ;
17641 int res1 = 0 ;
17642 bool temp2 = false ;
17643 PyObject * obj0 = 0 ;
17644 PyObject * obj1 = 0 ;
17645 char * kwnames[] = {
17646 (char *) "self",(char *) "ext", NULL
17647 };
17648
17649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17651 if (!SWIG_IsOK(res1)) {
17652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17653 }
17654 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17655 {
17656 arg2 = wxString_in_helper(obj1);
17657 if (arg2 == NULL) SWIG_fail;
17658 temp2 = true;
17659 }
17660 {
17661 PyThreadState* __tstate = wxPyBeginAllowThreads();
17662 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17663 wxPyEndAllowThreads(__tstate);
17664 if (PyErr_Occurred()) SWIG_fail;
17665 }
17666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17667 {
17668 if (temp2)
17669 delete arg2;
17670 }
17671 return resultobj;
17672 fail:
17673 {
17674 if (temp2)
17675 delete arg2;
17676 }
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj = 0;
17683 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17684 wxString *arg2 = 0 ;
17685 wxFileType *result = 0 ;
17686 void *argp1 = 0 ;
17687 int res1 = 0 ;
17688 bool temp2 = false ;
17689 PyObject * obj0 = 0 ;
17690 PyObject * obj1 = 0 ;
17691 char * kwnames[] = {
17692 (char *) "self",(char *) "mimeType", NULL
17693 };
17694
17695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17697 if (!SWIG_IsOK(res1)) {
17698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17699 }
17700 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17701 {
17702 arg2 = wxString_in_helper(obj1);
17703 if (arg2 == NULL) SWIG_fail;
17704 temp2 = true;
17705 }
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17713 {
17714 if (temp2)
17715 delete arg2;
17716 }
17717 return resultobj;
17718 fail:
17719 {
17720 if (temp2)
17721 delete arg2;
17722 }
17723 return NULL;
17724 }
17725
17726
17727 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17728 PyObject *resultobj = 0;
17729 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17730 wxString *arg2 = 0 ;
17731 bool arg3 = (bool) false ;
17732 bool result;
17733 void *argp1 = 0 ;
17734 int res1 = 0 ;
17735 bool temp2 = false ;
17736 bool val3 ;
17737 int ecode3 = 0 ;
17738 PyObject * obj0 = 0 ;
17739 PyObject * obj1 = 0 ;
17740 PyObject * obj2 = 0 ;
17741 char * kwnames[] = {
17742 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17743 };
17744
17745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17747 if (!SWIG_IsOK(res1)) {
17748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17749 }
17750 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17751 {
17752 arg2 = wxString_in_helper(obj1);
17753 if (arg2 == NULL) SWIG_fail;
17754 temp2 = true;
17755 }
17756 if (obj2) {
17757 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17758 if (!SWIG_IsOK(ecode3)) {
17759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17760 }
17761 arg3 = static_cast< bool >(val3);
17762 }
17763 {
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17766 wxPyEndAllowThreads(__tstate);
17767 if (PyErr_Occurred()) SWIG_fail;
17768 }
17769 {
17770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17771 }
17772 {
17773 if (temp2)
17774 delete arg2;
17775 }
17776 return resultobj;
17777 fail:
17778 {
17779 if (temp2)
17780 delete arg2;
17781 }
17782 return NULL;
17783 }
17784
17785
17786 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17787 PyObject *resultobj = 0;
17788 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17789 wxString *arg2 = 0 ;
17790 bool result;
17791 void *argp1 = 0 ;
17792 int res1 = 0 ;
17793 bool temp2 = false ;
17794 PyObject * obj0 = 0 ;
17795 PyObject * obj1 = 0 ;
17796 char * kwnames[] = {
17797 (char *) "self",(char *) "filename", NULL
17798 };
17799
17800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17802 if (!SWIG_IsOK(res1)) {
17803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17804 }
17805 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17806 {
17807 arg2 = wxString_in_helper(obj1);
17808 if (arg2 == NULL) SWIG_fail;
17809 temp2 = true;
17810 }
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17819 }
17820 {
17821 if (temp2)
17822 delete arg2;
17823 }
17824 return resultobj;
17825 fail:
17826 {
17827 if (temp2)
17828 delete arg2;
17829 }
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17835 PyObject *resultobj = 0;
17836 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17837 PyObject *result = 0 ;
17838 void *argp1 = 0 ;
17839 int res1 = 0 ;
17840 PyObject *swig_obj[1] ;
17841
17842 if (!args) SWIG_fail;
17843 swig_obj[0] = args;
17844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17845 if (!SWIG_IsOK(res1)) {
17846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17847 }
17848 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 resultobj = result;
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj = 0;
17864 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17865 wxFileTypeInfo *arg2 = 0 ;
17866 void *argp1 = 0 ;
17867 int res1 = 0 ;
17868 void *argp2 = 0 ;
17869 int res2 = 0 ;
17870 PyObject * obj0 = 0 ;
17871 PyObject * obj1 = 0 ;
17872 char * kwnames[] = {
17873 (char *) "self",(char *) "ft", NULL
17874 };
17875
17876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17878 if (!SWIG_IsOK(res1)) {
17879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17880 }
17881 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17883 if (!SWIG_IsOK(res2)) {
17884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17885 }
17886 if (!argp2) {
17887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17888 }
17889 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 resultobj = SWIG_Py_Void();
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17904 PyObject *resultobj = 0;
17905 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17906 wxFileTypeInfo *arg2 = 0 ;
17907 wxFileType *result = 0 ;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 void *argp2 = 0 ;
17911 int res2 = 0 ;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17914 char * kwnames[] = {
17915 (char *) "self",(char *) "ftInfo", NULL
17916 };
17917
17918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17920 if (!SWIG_IsOK(res1)) {
17921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17922 }
17923 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17925 if (!SWIG_IsOK(res2)) {
17926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17927 }
17928 if (!argp2) {
17929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17930 }
17931 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj = 0;
17947 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17948 wxFileType *arg2 = (wxFileType *) 0 ;
17949 bool result;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 void *argp2 = 0 ;
17953 int res2 = 0 ;
17954 PyObject * obj0 = 0 ;
17955 PyObject * obj1 = 0 ;
17956 char * kwnames[] = {
17957 (char *) "self",(char *) "ft", NULL
17958 };
17959
17960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17962 if (!SWIG_IsOK(res1)) {
17963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17964 }
17965 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17967 if (!SWIG_IsOK(res2)) {
17968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17969 }
17970 arg2 = reinterpret_cast< wxFileType * >(argp2);
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 result = (bool)(arg1)->Unassociate(arg2);
17974 wxPyEndAllowThreads(__tstate);
17975 if (PyErr_Occurred()) SWIG_fail;
17976 }
17977 {
17978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17979 }
17980 return resultobj;
17981 fail:
17982 return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 PyObject *resultobj = 0;
17988 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17989 void *argp1 = 0 ;
17990 int res1 = 0 ;
17991 PyObject *swig_obj[1] ;
17992
17993 if (!args) SWIG_fail;
17994 swig_obj[0] = args;
17995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17996 if (!SWIG_IsOK(res1)) {
17997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17998 }
17999 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18000 {
18001 PyThreadState* __tstate = wxPyBeginAllowThreads();
18002 delete arg1;
18003
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 resultobj = SWIG_Py_Void();
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18015 PyObject *obj;
18016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18017 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18018 return SWIG_Py_Void();
18019 }
18020
18021 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18022 return SWIG_Python_InitShadowInstance(args);
18023 }
18024
18025 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18026 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18027 return 1;
18028 }
18029
18030
18031 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18032 PyObject *pyobj = 0;
18033
18034 {
18035 #if wxUSE_UNICODE
18036 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18037 #else
18038 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18039 #endif
18040 }
18041 return pyobj;
18042 }
18043
18044
18045 SWIGINTERN int ART_MENU_set(PyObject *) {
18046 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18047 return 1;
18048 }
18049
18050
18051 SWIGINTERN PyObject *ART_MENU_get(void) {
18052 PyObject *pyobj = 0;
18053
18054 {
18055 #if wxUSE_UNICODE
18056 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18057 #else
18058 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18059 #endif
18060 }
18061 return pyobj;
18062 }
18063
18064
18065 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18066 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18067 return 1;
18068 }
18069
18070
18071 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18072 PyObject *pyobj = 0;
18073
18074 {
18075 #if wxUSE_UNICODE
18076 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18077 #else
18078 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18079 #endif
18080 }
18081 return pyobj;
18082 }
18083
18084
18085 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18086 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18087 return 1;
18088 }
18089
18090
18091 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18092 PyObject *pyobj = 0;
18093
18094 {
18095 #if wxUSE_UNICODE
18096 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18097 #else
18098 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18099 #endif
18100 }
18101 return pyobj;
18102 }
18103
18104
18105 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18106 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18107 return 1;
18108 }
18109
18110
18111 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18112 PyObject *pyobj = 0;
18113
18114 {
18115 #if wxUSE_UNICODE
18116 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18117 #else
18118 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18119 #endif
18120 }
18121 return pyobj;
18122 }
18123
18124
18125 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18126 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18127 return 1;
18128 }
18129
18130
18131 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18132 PyObject *pyobj = 0;
18133
18134 {
18135 #if wxUSE_UNICODE
18136 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18137 #else
18138 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18139 #endif
18140 }
18141 return pyobj;
18142 }
18143
18144
18145 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18146 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18147 return 1;
18148 }
18149
18150
18151 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18152 PyObject *pyobj = 0;
18153
18154 {
18155 #if wxUSE_UNICODE
18156 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18157 #else
18158 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18159 #endif
18160 }
18161 return pyobj;
18162 }
18163
18164
18165 SWIGINTERN int ART_OTHER_set(PyObject *) {
18166 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18167 return 1;
18168 }
18169
18170
18171 SWIGINTERN PyObject *ART_OTHER_get(void) {
18172 PyObject *pyobj = 0;
18173
18174 {
18175 #if wxUSE_UNICODE
18176 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18177 #else
18178 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18179 #endif
18180 }
18181 return pyobj;
18182 }
18183
18184
18185 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18186 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18187 return 1;
18188 }
18189
18190
18191 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18192 PyObject *pyobj = 0;
18193
18194 {
18195 #if wxUSE_UNICODE
18196 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18197 #else
18198 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18199 #endif
18200 }
18201 return pyobj;
18202 }
18203
18204
18205 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18206 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18207 return 1;
18208 }
18209
18210
18211 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18212 PyObject *pyobj = 0;
18213
18214 {
18215 #if wxUSE_UNICODE
18216 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18217 #else
18218 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18219 #endif
18220 }
18221 return pyobj;
18222 }
18223
18224
18225 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18226 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18227 return 1;
18228 }
18229
18230
18231 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18232 PyObject *pyobj = 0;
18233
18234 {
18235 #if wxUSE_UNICODE
18236 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18237 #else
18238 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18239 #endif
18240 }
18241 return pyobj;
18242 }
18243
18244
18245 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18246 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18247 return 1;
18248 }
18249
18250
18251 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18252 PyObject *pyobj = 0;
18253
18254 {
18255 #if wxUSE_UNICODE
18256 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18257 #else
18258 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18259 #endif
18260 }
18261 return pyobj;
18262 }
18263
18264
18265 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18266 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18267 return 1;
18268 }
18269
18270
18271 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18272 PyObject *pyobj = 0;
18273
18274 {
18275 #if wxUSE_UNICODE
18276 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18277 #else
18278 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18279 #endif
18280 }
18281 return pyobj;
18282 }
18283
18284
18285 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18286 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18287 return 1;
18288 }
18289
18290
18291 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18292 PyObject *pyobj = 0;
18293
18294 {
18295 #if wxUSE_UNICODE
18296 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18297 #else
18298 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18299 #endif
18300 }
18301 return pyobj;
18302 }
18303
18304
18305 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18306 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18307 return 1;
18308 }
18309
18310
18311 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18312 PyObject *pyobj = 0;
18313
18314 {
18315 #if wxUSE_UNICODE
18316 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18317 #else
18318 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18319 #endif
18320 }
18321 return pyobj;
18322 }
18323
18324
18325 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18326 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18327 return 1;
18328 }
18329
18330
18331 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18332 PyObject *pyobj = 0;
18333
18334 {
18335 #if wxUSE_UNICODE
18336 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18337 #else
18338 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18339 #endif
18340 }
18341 return pyobj;
18342 }
18343
18344
18345 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18346 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18347 return 1;
18348 }
18349
18350
18351 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18352 PyObject *pyobj = 0;
18353
18354 {
18355 #if wxUSE_UNICODE
18356 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18357 #else
18358 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18359 #endif
18360 }
18361 return pyobj;
18362 }
18363
18364
18365 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18366 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18367 return 1;
18368 }
18369
18370
18371 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18372 PyObject *pyobj = 0;
18373
18374 {
18375 #if wxUSE_UNICODE
18376 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18377 #else
18378 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18379 #endif
18380 }
18381 return pyobj;
18382 }
18383
18384
18385 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18386 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18387 return 1;
18388 }
18389
18390
18391 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18392 PyObject *pyobj = 0;
18393
18394 {
18395 #if wxUSE_UNICODE
18396 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18397 #else
18398 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18399 #endif
18400 }
18401 return pyobj;
18402 }
18403
18404
18405 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18406 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18407 return 1;
18408 }
18409
18410
18411 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18412 PyObject *pyobj = 0;
18413
18414 {
18415 #if wxUSE_UNICODE
18416 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18417 #else
18418 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18419 #endif
18420 }
18421 return pyobj;
18422 }
18423
18424
18425 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18426 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18427 return 1;
18428 }
18429
18430
18431 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18432 PyObject *pyobj = 0;
18433
18434 {
18435 #if wxUSE_UNICODE
18436 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18437 #else
18438 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18439 #endif
18440 }
18441 return pyobj;
18442 }
18443
18444
18445 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18446 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18447 return 1;
18448 }
18449
18450
18451 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18452 PyObject *pyobj = 0;
18453
18454 {
18455 #if wxUSE_UNICODE
18456 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18457 #else
18458 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18459 #endif
18460 }
18461 return pyobj;
18462 }
18463
18464
18465 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18466 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18467 return 1;
18468 }
18469
18470
18471 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18472 PyObject *pyobj = 0;
18473
18474 {
18475 #if wxUSE_UNICODE
18476 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18477 #else
18478 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18479 #endif
18480 }
18481 return pyobj;
18482 }
18483
18484
18485 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18486 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18487 return 1;
18488 }
18489
18490
18491 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18492 PyObject *pyobj = 0;
18493
18494 {
18495 #if wxUSE_UNICODE
18496 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18497 #else
18498 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18499 #endif
18500 }
18501 return pyobj;
18502 }
18503
18504
18505 SWIGINTERN int ART_PRINT_set(PyObject *) {
18506 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18507 return 1;
18508 }
18509
18510
18511 SWIGINTERN PyObject *ART_PRINT_get(void) {
18512 PyObject *pyobj = 0;
18513
18514 {
18515 #if wxUSE_UNICODE
18516 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18517 #else
18518 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18519 #endif
18520 }
18521 return pyobj;
18522 }
18523
18524
18525 SWIGINTERN int ART_HELP_set(PyObject *) {
18526 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18527 return 1;
18528 }
18529
18530
18531 SWIGINTERN PyObject *ART_HELP_get(void) {
18532 PyObject *pyobj = 0;
18533
18534 {
18535 #if wxUSE_UNICODE
18536 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18537 #else
18538 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18539 #endif
18540 }
18541 return pyobj;
18542 }
18543
18544
18545 SWIGINTERN int ART_TIP_set(PyObject *) {
18546 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18547 return 1;
18548 }
18549
18550
18551 SWIGINTERN PyObject *ART_TIP_get(void) {
18552 PyObject *pyobj = 0;
18553
18554 {
18555 #if wxUSE_UNICODE
18556 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18557 #else
18558 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18559 #endif
18560 }
18561 return pyobj;
18562 }
18563
18564
18565 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18566 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18567 return 1;
18568 }
18569
18570
18571 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18572 PyObject *pyobj = 0;
18573
18574 {
18575 #if wxUSE_UNICODE
18576 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18577 #else
18578 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18579 #endif
18580 }
18581 return pyobj;
18582 }
18583
18584
18585 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18586 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18587 return 1;
18588 }
18589
18590
18591 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18592 PyObject *pyobj = 0;
18593
18594 {
18595 #if wxUSE_UNICODE
18596 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18597 #else
18598 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18599 #endif
18600 }
18601 return pyobj;
18602 }
18603
18604
18605 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18606 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18607 return 1;
18608 }
18609
18610
18611 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18612 PyObject *pyobj = 0;
18613
18614 {
18615 #if wxUSE_UNICODE
18616 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18617 #else
18618 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18619 #endif
18620 }
18621 return pyobj;
18622 }
18623
18624
18625 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18626 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18627 return 1;
18628 }
18629
18630
18631 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18632 PyObject *pyobj = 0;
18633
18634 {
18635 #if wxUSE_UNICODE
18636 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18637 #else
18638 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18639 #endif
18640 }
18641 return pyobj;
18642 }
18643
18644
18645 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18646 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18647 return 1;
18648 }
18649
18650
18651 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18652 PyObject *pyobj = 0;
18653
18654 {
18655 #if wxUSE_UNICODE
18656 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18657 #else
18658 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18659 #endif
18660 }
18661 return pyobj;
18662 }
18663
18664
18665 SWIGINTERN int ART_CDROM_set(PyObject *) {
18666 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18667 return 1;
18668 }
18669
18670
18671 SWIGINTERN PyObject *ART_CDROM_get(void) {
18672 PyObject *pyobj = 0;
18673
18674 {
18675 #if wxUSE_UNICODE
18676 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18677 #else
18678 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18679 #endif
18680 }
18681 return pyobj;
18682 }
18683
18684
18685 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18686 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18687 return 1;
18688 }
18689
18690
18691 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18692 PyObject *pyobj = 0;
18693
18694 {
18695 #if wxUSE_UNICODE
18696 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18697 #else
18698 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18699 #endif
18700 }
18701 return pyobj;
18702 }
18703
18704
18705 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18706 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18707 return 1;
18708 }
18709
18710
18711 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18712 PyObject *pyobj = 0;
18713
18714 {
18715 #if wxUSE_UNICODE
18716 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18717 #else
18718 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18719 #endif
18720 }
18721 return pyobj;
18722 }
18723
18724
18725 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18726 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18727 return 1;
18728 }
18729
18730
18731 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18732 PyObject *pyobj = 0;
18733
18734 {
18735 #if wxUSE_UNICODE
18736 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18737 #else
18738 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18739 #endif
18740 }
18741 return pyobj;
18742 }
18743
18744
18745 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18746 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18747 return 1;
18748 }
18749
18750
18751 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18752 PyObject *pyobj = 0;
18753
18754 {
18755 #if wxUSE_UNICODE
18756 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18757 #else
18758 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18759 #endif
18760 }
18761 return pyobj;
18762 }
18763
18764
18765 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18766 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18767 return 1;
18768 }
18769
18770
18771 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18772 PyObject *pyobj = 0;
18773
18774 {
18775 #if wxUSE_UNICODE
18776 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18777 #else
18778 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18779 #endif
18780 }
18781 return pyobj;
18782 }
18783
18784
18785 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18786 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18787 return 1;
18788 }
18789
18790
18791 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18792 PyObject *pyobj = 0;
18793
18794 {
18795 #if wxUSE_UNICODE
18796 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18797 #else
18798 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18799 #endif
18800 }
18801 return pyobj;
18802 }
18803
18804
18805 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18806 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18807 return 1;
18808 }
18809
18810
18811 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18812 PyObject *pyobj = 0;
18813
18814 {
18815 #if wxUSE_UNICODE
18816 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18817 #else
18818 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18819 #endif
18820 }
18821 return pyobj;
18822 }
18823
18824
18825 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18826 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18827 return 1;
18828 }
18829
18830
18831 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18832 PyObject *pyobj = 0;
18833
18834 {
18835 #if wxUSE_UNICODE
18836 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18837 #else
18838 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18839 #endif
18840 }
18841 return pyobj;
18842 }
18843
18844
18845 SWIGINTERN int ART_ERROR_set(PyObject *) {
18846 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18847 return 1;
18848 }
18849
18850
18851 SWIGINTERN PyObject *ART_ERROR_get(void) {
18852 PyObject *pyobj = 0;
18853
18854 {
18855 #if wxUSE_UNICODE
18856 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18857 #else
18858 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18859 #endif
18860 }
18861 return pyobj;
18862 }
18863
18864
18865 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18866 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18867 return 1;
18868 }
18869
18870
18871 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18872 PyObject *pyobj = 0;
18873
18874 {
18875 #if wxUSE_UNICODE
18876 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18877 #else
18878 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18879 #endif
18880 }
18881 return pyobj;
18882 }
18883
18884
18885 SWIGINTERN int ART_WARNING_set(PyObject *) {
18886 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18887 return 1;
18888 }
18889
18890
18891 SWIGINTERN PyObject *ART_WARNING_get(void) {
18892 PyObject *pyobj = 0;
18893
18894 {
18895 #if wxUSE_UNICODE
18896 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18897 #else
18898 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18899 #endif
18900 }
18901 return pyobj;
18902 }
18903
18904
18905 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18906 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18907 return 1;
18908 }
18909
18910
18911 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18912 PyObject *pyobj = 0;
18913
18914 {
18915 #if wxUSE_UNICODE
18916 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18917 #else
18918 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18919 #endif
18920 }
18921 return pyobj;
18922 }
18923
18924
18925 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18926 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18927 return 1;
18928 }
18929
18930
18931 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18932 PyObject *pyobj = 0;
18933
18934 {
18935 #if wxUSE_UNICODE
18936 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18937 #else
18938 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18939 #endif
18940 }
18941 return pyobj;
18942 }
18943
18944
18945 SWIGINTERN int ART_COPY_set(PyObject *) {
18946 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18947 return 1;
18948 }
18949
18950
18951 SWIGINTERN PyObject *ART_COPY_get(void) {
18952 PyObject *pyobj = 0;
18953
18954 {
18955 #if wxUSE_UNICODE
18956 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18957 #else
18958 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18959 #endif
18960 }
18961 return pyobj;
18962 }
18963
18964
18965 SWIGINTERN int ART_CUT_set(PyObject *) {
18966 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18967 return 1;
18968 }
18969
18970
18971 SWIGINTERN PyObject *ART_CUT_get(void) {
18972 PyObject *pyobj = 0;
18973
18974 {
18975 #if wxUSE_UNICODE
18976 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18977 #else
18978 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18979 #endif
18980 }
18981 return pyobj;
18982 }
18983
18984
18985 SWIGINTERN int ART_PASTE_set(PyObject *) {
18986 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18987 return 1;
18988 }
18989
18990
18991 SWIGINTERN PyObject *ART_PASTE_get(void) {
18992 PyObject *pyobj = 0;
18993
18994 {
18995 #if wxUSE_UNICODE
18996 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18997 #else
18998 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18999 #endif
19000 }
19001 return pyobj;
19002 }
19003
19004
19005 SWIGINTERN int ART_DELETE_set(PyObject *) {
19006 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19007 return 1;
19008 }
19009
19010
19011 SWIGINTERN PyObject *ART_DELETE_get(void) {
19012 PyObject *pyobj = 0;
19013
19014 {
19015 #if wxUSE_UNICODE
19016 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19017 #else
19018 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19019 #endif
19020 }
19021 return pyobj;
19022 }
19023
19024
19025 SWIGINTERN int ART_NEW_set(PyObject *) {
19026 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19027 return 1;
19028 }
19029
19030
19031 SWIGINTERN PyObject *ART_NEW_get(void) {
19032 PyObject *pyobj = 0;
19033
19034 {
19035 #if wxUSE_UNICODE
19036 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19037 #else
19038 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19039 #endif
19040 }
19041 return pyobj;
19042 }
19043
19044
19045 SWIGINTERN int ART_UNDO_set(PyObject *) {
19046 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19047 return 1;
19048 }
19049
19050
19051 SWIGINTERN PyObject *ART_UNDO_get(void) {
19052 PyObject *pyobj = 0;
19053
19054 {
19055 #if wxUSE_UNICODE
19056 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19057 #else
19058 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19059 #endif
19060 }
19061 return pyobj;
19062 }
19063
19064
19065 SWIGINTERN int ART_REDO_set(PyObject *) {
19066 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19067 return 1;
19068 }
19069
19070
19071 SWIGINTERN PyObject *ART_REDO_get(void) {
19072 PyObject *pyobj = 0;
19073
19074 {
19075 #if wxUSE_UNICODE
19076 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19077 #else
19078 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19079 #endif
19080 }
19081 return pyobj;
19082 }
19083
19084
19085 SWIGINTERN int ART_QUIT_set(PyObject *) {
19086 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19087 return 1;
19088 }
19089
19090
19091 SWIGINTERN PyObject *ART_QUIT_get(void) {
19092 PyObject *pyobj = 0;
19093
19094 {
19095 #if wxUSE_UNICODE
19096 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19097 #else
19098 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19099 #endif
19100 }
19101 return pyobj;
19102 }
19103
19104
19105 SWIGINTERN int ART_FIND_set(PyObject *) {
19106 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19107 return 1;
19108 }
19109
19110
19111 SWIGINTERN PyObject *ART_FIND_get(void) {
19112 PyObject *pyobj = 0;
19113
19114 {
19115 #if wxUSE_UNICODE
19116 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19117 #else
19118 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19119 #endif
19120 }
19121 return pyobj;
19122 }
19123
19124
19125 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19126 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19127 return 1;
19128 }
19129
19130
19131 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19132 PyObject *pyobj = 0;
19133
19134 {
19135 #if wxUSE_UNICODE
19136 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19137 #else
19138 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19139 #endif
19140 }
19141 return pyobj;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 PyObject *resultobj = 0;
19147 wxPyArtProvider *result = 0 ;
19148
19149 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19150 {
19151 if (!wxPyCheckForApp()) SWIG_fail;
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (wxPyArtProvider *)new wxPyArtProvider();
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165 PyObject *resultobj = 0;
19166 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 PyObject *swig_obj[1] ;
19170
19171 if (!args) SWIG_fail;
19172 swig_obj[0] = args;
19173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19176 }
19177 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 delete arg1;
19181
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 resultobj = SWIG_Py_Void();
19186 return resultobj;
19187 fail:
19188 return NULL;
19189 }
19190
19191
19192 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19193 PyObject *resultobj = 0;
19194 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19195 PyObject *arg2 = (PyObject *) 0 ;
19196 PyObject *arg3 = (PyObject *) 0 ;
19197 void *argp1 = 0 ;
19198 int res1 = 0 ;
19199 PyObject * obj0 = 0 ;
19200 PyObject * obj1 = 0 ;
19201 PyObject * obj2 = 0 ;
19202 char * kwnames[] = {
19203 (char *) "self",(char *) "self",(char *) "_class", NULL
19204 };
19205
19206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19208 if (!SWIG_IsOK(res1)) {
19209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19210 }
19211 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19212 arg2 = obj1;
19213 arg3 = obj2;
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 (arg1)->_setCallbackInfo(arg2,arg3);
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 resultobj = SWIG_Py_Void();
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj = 0;
19229 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19230 int res1 = 0 ;
19231 PyObject * obj0 = 0 ;
19232 char * kwnames[] = {
19233 (char *) "provider", NULL
19234 };
19235
19236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19237 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19238 if (!SWIG_IsOK(res1)) {
19239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 wxPyArtProvider::PushProvider(arg1);
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 resultobj = SWIG_Py_Void();
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19255 PyObject *resultobj = 0;
19256 bool result;
19257
19258 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 result = (bool)wxPyArtProvider::PopProvider();
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 {
19266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19267 }
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj = 0;
19276 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19277 bool result;
19278 void *argp1 = 0 ;
19279 int res1 = 0 ;
19280 PyObject * obj0 = 0 ;
19281 char * kwnames[] = {
19282 (char *) "provider", NULL
19283 };
19284
19285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19287 if (!SWIG_IsOK(res1)) {
19288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19289 }
19290 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 {
19298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19299 }
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19307 PyObject *resultobj = 0;
19308 wxString *arg1 = 0 ;
19309 wxString const &arg2_defvalue = wxPyART_OTHER ;
19310 wxString *arg2 = (wxString *) &arg2_defvalue ;
19311 wxSize const &arg3_defvalue = wxDefaultSize ;
19312 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19313 wxBitmap result;
19314 bool temp1 = false ;
19315 bool temp2 = false ;
19316 wxSize temp3 ;
19317 PyObject * obj0 = 0 ;
19318 PyObject * obj1 = 0 ;
19319 PyObject * obj2 = 0 ;
19320 char * kwnames[] = {
19321 (char *) "id",(char *) "client",(char *) "size", NULL
19322 };
19323
19324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19325 {
19326 arg1 = wxString_in_helper(obj0);
19327 if (arg1 == NULL) SWIG_fail;
19328 temp1 = true;
19329 }
19330 if (obj1) {
19331 {
19332 arg2 = wxString_in_helper(obj1);
19333 if (arg2 == NULL) SWIG_fail;
19334 temp2 = true;
19335 }
19336 }
19337 if (obj2) {
19338 {
19339 arg3 = &temp3;
19340 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19341 }
19342 }
19343 {
19344 if (!wxPyCheckForApp()) SWIG_fail;
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19347 wxPyEndAllowThreads(__tstate);
19348 if (PyErr_Occurred()) SWIG_fail;
19349 }
19350 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19351 {
19352 if (temp1)
19353 delete arg1;
19354 }
19355 {
19356 if (temp2)
19357 delete arg2;
19358 }
19359 return resultobj;
19360 fail:
19361 {
19362 if (temp1)
19363 delete arg1;
19364 }
19365 {
19366 if (temp2)
19367 delete arg2;
19368 }
19369 return NULL;
19370 }
19371
19372
19373 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj = 0;
19375 wxString *arg1 = 0 ;
19376 wxString const &arg2_defvalue = wxPyART_OTHER ;
19377 wxString *arg2 = (wxString *) &arg2_defvalue ;
19378 wxSize const &arg3_defvalue = wxDefaultSize ;
19379 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19380 wxIcon result;
19381 bool temp1 = false ;
19382 bool temp2 = false ;
19383 wxSize temp3 ;
19384 PyObject * obj0 = 0 ;
19385 PyObject * obj1 = 0 ;
19386 PyObject * obj2 = 0 ;
19387 char * kwnames[] = {
19388 (char *) "id",(char *) "client",(char *) "size", NULL
19389 };
19390
19391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19392 {
19393 arg1 = wxString_in_helper(obj0);
19394 if (arg1 == NULL) SWIG_fail;
19395 temp1 = true;
19396 }
19397 if (obj1) {
19398 {
19399 arg2 = wxString_in_helper(obj1);
19400 if (arg2 == NULL) SWIG_fail;
19401 temp2 = true;
19402 }
19403 }
19404 if (obj2) {
19405 {
19406 arg3 = &temp3;
19407 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19408 }
19409 }
19410 {
19411 if (!wxPyCheckForApp()) SWIG_fail;
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19418 {
19419 if (temp1)
19420 delete arg1;
19421 }
19422 {
19423 if (temp2)
19424 delete arg2;
19425 }
19426 return resultobj;
19427 fail:
19428 {
19429 if (temp1)
19430 delete arg1;
19431 }
19432 {
19433 if (temp2)
19434 delete arg2;
19435 }
19436 return NULL;
19437 }
19438
19439
19440 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19441 PyObject *resultobj = 0;
19442 wxString *arg1 = 0 ;
19443 bool arg2 = (bool) false ;
19444 wxSize result;
19445 bool temp1 = false ;
19446 bool val2 ;
19447 int ecode2 = 0 ;
19448 PyObject * obj0 = 0 ;
19449 PyObject * obj1 = 0 ;
19450 char * kwnames[] = {
19451 (char *) "client",(char *) "platform_dependent", NULL
19452 };
19453
19454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19455 {
19456 arg1 = wxString_in_helper(obj0);
19457 if (arg1 == NULL) SWIG_fail;
19458 temp1 = true;
19459 }
19460 if (obj1) {
19461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19462 if (!SWIG_IsOK(ecode2)) {
19463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19464 }
19465 arg2 = static_cast< bool >(val2);
19466 }
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19474 {
19475 if (temp1)
19476 delete arg1;
19477 }
19478 return resultobj;
19479 fail:
19480 {
19481 if (temp1)
19482 delete arg1;
19483 }
19484 return NULL;
19485 }
19486
19487
19488 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19489 PyObject *resultobj = 0;
19490 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19491 void *argp1 = 0 ;
19492 int res1 = 0 ;
19493 PyObject *swig_obj[1] ;
19494
19495 if (!args) SWIG_fail;
19496 swig_obj[0] = args;
19497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19498 if (!SWIG_IsOK(res1)) {
19499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19500 }
19501 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19502 {
19503 PyThreadState* __tstate = wxPyBeginAllowThreads();
19504 wxPyArtProvider_Destroy(arg1);
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 resultobj = SWIG_Py_Void();
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19516 PyObject *obj;
19517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19518 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19519 return SWIG_Py_Void();
19520 }
19521
19522 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19523 return SWIG_Python_InitShadowInstance(args);
19524 }
19525
19526 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527 PyObject *resultobj = 0;
19528 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19529 void *argp1 = 0 ;
19530 int res1 = 0 ;
19531 PyObject *swig_obj[1] ;
19532
19533 if (!args) SWIG_fail;
19534 swig_obj[0] = args;
19535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19536 if (!SWIG_IsOK(res1)) {
19537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19538 }
19539 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 delete arg1;
19543
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 resultobj = SWIG_Py_Void();
19548 return resultobj;
19549 fail:
19550 return NULL;
19551 }
19552
19553
19554 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19555 PyObject *resultobj = 0;
19556 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19557 wxConfigBase *result = 0 ;
19558 int res1 = 0 ;
19559 PyObject * obj0 = 0 ;
19560 char * kwnames[] = {
19561 (char *) "config", NULL
19562 };
19563
19564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19565 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19566 if (!SWIG_IsOK(res1)) {
19567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19568 }
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19576 return resultobj;
19577 fail:
19578 return NULL;
19579 }
19580
19581
19582 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19583 PyObject *resultobj = 0;
19584 bool arg1 = (bool) true ;
19585 wxConfigBase *result = 0 ;
19586 bool val1 ;
19587 int ecode1 = 0 ;
19588 PyObject * obj0 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "createOnDemand", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19594 if (obj0) {
19595 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19596 if (!SWIG_IsOK(ecode1)) {
19597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19598 }
19599 arg1 = static_cast< bool >(val1);
19600 }
19601 {
19602 PyThreadState* __tstate = wxPyBeginAllowThreads();
19603 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19615 PyObject *resultobj = 0;
19616 wxConfigBase *result = 0 ;
19617
19618 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19619 {
19620 PyThreadState* __tstate = wxPyBeginAllowThreads();
19621 result = (wxConfigBase *)wxConfigBase::Create();
19622 wxPyEndAllowThreads(__tstate);
19623 if (PyErr_Occurred()) SWIG_fail;
19624 }
19625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19633 PyObject *resultobj = 0;
19634
19635 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 wxConfigBase::DontCreateOnDemand();
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 resultobj = SWIG_Py_Void();
19643 return resultobj;
19644 fail:
19645 return NULL;
19646 }
19647
19648
19649 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj = 0;
19651 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19652 wxString *arg2 = 0 ;
19653 void *argp1 = 0 ;
19654 int res1 = 0 ;
19655 bool temp2 = false ;
19656 PyObject * obj0 = 0 ;
19657 PyObject * obj1 = 0 ;
19658 char * kwnames[] = {
19659 (char *) "self",(char *) "path", NULL
19660 };
19661
19662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19664 if (!SWIG_IsOK(res1)) {
19665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19666 }
19667 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19668 {
19669 arg2 = wxString_in_helper(obj1);
19670 if (arg2 == NULL) SWIG_fail;
19671 temp2 = true;
19672 }
19673 {
19674 PyThreadState* __tstate = wxPyBeginAllowThreads();
19675 (arg1)->SetPath((wxString const &)*arg2);
19676 wxPyEndAllowThreads(__tstate);
19677 if (PyErr_Occurred()) SWIG_fail;
19678 }
19679 resultobj = SWIG_Py_Void();
19680 {
19681 if (temp2)
19682 delete arg2;
19683 }
19684 return resultobj;
19685 fail:
19686 {
19687 if (temp2)
19688 delete arg2;
19689 }
19690 return NULL;
19691 }
19692
19693
19694 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19695 PyObject *resultobj = 0;
19696 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19697 wxString *result = 0 ;
19698 void *argp1 = 0 ;
19699 int res1 = 0 ;
19700 PyObject *swig_obj[1] ;
19701
19702 if (!args) SWIG_fail;
19703 swig_obj[0] = args;
19704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19705 if (!SWIG_IsOK(res1)) {
19706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19707 }
19708 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 {
19712 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19713 result = (wxString *) &_result_ref;
19714 }
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 {
19719 #if wxUSE_UNICODE
19720 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19721 #else
19722 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19723 #endif
19724 }
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19732 PyObject *resultobj = 0;
19733 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19734 PyObject *result = 0 ;
19735 void *argp1 = 0 ;
19736 int res1 = 0 ;
19737 PyObject *swig_obj[1] ;
19738
19739 if (!args) SWIG_fail;
19740 swig_obj[0] = args;
19741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19742 if (!SWIG_IsOK(res1)) {
19743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19744 }
19745 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19746 {
19747 PyThreadState* __tstate = wxPyBeginAllowThreads();
19748 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 resultobj = result;
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj = 0;
19761 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19762 long arg2 ;
19763 PyObject *result = 0 ;
19764 void *argp1 = 0 ;
19765 int res1 = 0 ;
19766 long val2 ;
19767 int ecode2 = 0 ;
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 char * kwnames[] = {
19771 (char *) "self",(char *) "index", NULL
19772 };
19773
19774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19776 if (!SWIG_IsOK(res1)) {
19777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19778 }
19779 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19780 ecode2 = SWIG_AsVal_long(obj1, &val2);
19781 if (!SWIG_IsOK(ecode2)) {
19782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19783 }
19784 arg2 = static_cast< long >(val2);
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = result;
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19799 PyObject *resultobj = 0;
19800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19801 PyObject *result = 0 ;
19802 void *argp1 = 0 ;
19803 int res1 = 0 ;
19804 PyObject *swig_obj[1] ;
19805
19806 if (!args) SWIG_fail;
19807 swig_obj[0] = args;
19808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19809 if (!SWIG_IsOK(res1)) {
19810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19811 }
19812 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19816 wxPyEndAllowThreads(__tstate);
19817 if (PyErr_Occurred()) SWIG_fail;
19818 }
19819 resultobj = result;
19820 return resultobj;
19821 fail:
19822 return NULL;
19823 }
19824
19825
19826 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19827 PyObject *resultobj = 0;
19828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19829 long arg2 ;
19830 PyObject *result = 0 ;
19831 void *argp1 = 0 ;
19832 int res1 = 0 ;
19833 long val2 ;
19834 int ecode2 = 0 ;
19835 PyObject * obj0 = 0 ;
19836 PyObject * obj1 = 0 ;
19837 char * kwnames[] = {
19838 (char *) "self",(char *) "index", NULL
19839 };
19840
19841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19843 if (!SWIG_IsOK(res1)) {
19844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19845 }
19846 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19847 ecode2 = SWIG_AsVal_long(obj1, &val2);
19848 if (!SWIG_IsOK(ecode2)) {
19849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19850 }
19851 arg2 = static_cast< long >(val2);
19852 {
19853 PyThreadState* __tstate = wxPyBeginAllowThreads();
19854 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 resultobj = result;
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = 0;
19867 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19868 bool arg2 = (bool) false ;
19869 size_t result;
19870 void *argp1 = 0 ;
19871 int res1 = 0 ;
19872 bool val2 ;
19873 int ecode2 = 0 ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char * kwnames[] = {
19877 (char *) "self",(char *) "recursive", NULL
19878 };
19879
19880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19882 if (!SWIG_IsOK(res1)) {
19883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19884 }
19885 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19886 if (obj1) {
19887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19888 if (!SWIG_IsOK(ecode2)) {
19889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19890 }
19891 arg2 = static_cast< bool >(val2);
19892 }
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19907 PyObject *resultobj = 0;
19908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19909 bool arg2 = (bool) false ;
19910 size_t result;
19911 void *argp1 = 0 ;
19912 int res1 = 0 ;
19913 bool val2 ;
19914 int ecode2 = 0 ;
19915 PyObject * obj0 = 0 ;
19916 PyObject * obj1 = 0 ;
19917 char * kwnames[] = {
19918 (char *) "self",(char *) "recursive", NULL
19919 };
19920
19921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19923 if (!SWIG_IsOK(res1)) {
19924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19925 }
19926 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19927 if (obj1) {
19928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19929 if (!SWIG_IsOK(ecode2)) {
19930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19931 }
19932 arg2 = static_cast< bool >(val2);
19933 }
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19941 return resultobj;
19942 fail:
19943 return NULL;
19944 }
19945
19946
19947 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj = 0;
19949 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19950 wxString *arg2 = 0 ;
19951 bool result;
19952 void *argp1 = 0 ;
19953 int res1 = 0 ;
19954 bool temp2 = false ;
19955 PyObject * obj0 = 0 ;
19956 PyObject * obj1 = 0 ;
19957 char * kwnames[] = {
19958 (char *) "self",(char *) "name", NULL
19959 };
19960
19961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19965 }
19966 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19967 {
19968 arg2 = wxString_in_helper(obj1);
19969 if (arg2 == NULL) SWIG_fail;
19970 temp2 = true;
19971 }
19972 {
19973 PyThreadState* __tstate = wxPyBeginAllowThreads();
19974 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19975 wxPyEndAllowThreads(__tstate);
19976 if (PyErr_Occurred()) SWIG_fail;
19977 }
19978 {
19979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19980 }
19981 {
19982 if (temp2)
19983 delete arg2;
19984 }
19985 return resultobj;
19986 fail:
19987 {
19988 if (temp2)
19989 delete arg2;
19990 }
19991 return NULL;
19992 }
19993
19994
19995 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19996 PyObject *resultobj = 0;
19997 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19998 wxString *arg2 = 0 ;
19999 bool result;
20000 void *argp1 = 0 ;
20001 int res1 = 0 ;
20002 bool temp2 = false ;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char * kwnames[] = {
20006 (char *) "self",(char *) "name", NULL
20007 };
20008
20009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20011 if (!SWIG_IsOK(res1)) {
20012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20013 }
20014 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20015 {
20016 arg2 = wxString_in_helper(obj1);
20017 if (arg2 == NULL) SWIG_fail;
20018 temp2 = true;
20019 }
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 {
20027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20028 }
20029 {
20030 if (temp2)
20031 delete arg2;
20032 }
20033 return resultobj;
20034 fail:
20035 {
20036 if (temp2)
20037 delete arg2;
20038 }
20039 return NULL;
20040 }
20041
20042
20043 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20044 PyObject *resultobj = 0;
20045 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20046 wxString *arg2 = 0 ;
20047 bool result;
20048 void *argp1 = 0 ;
20049 int res1 = 0 ;
20050 bool temp2 = false ;
20051 PyObject * obj0 = 0 ;
20052 PyObject * obj1 = 0 ;
20053 char * kwnames[] = {
20054 (char *) "self",(char *) "name", NULL
20055 };
20056
20057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20059 if (!SWIG_IsOK(res1)) {
20060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20061 }
20062 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20063 {
20064 arg2 = wxString_in_helper(obj1);
20065 if (arg2 == NULL) SWIG_fail;
20066 temp2 = true;
20067 }
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20076 }
20077 {
20078 if (temp2)
20079 delete arg2;
20080 }
20081 return resultobj;
20082 fail:
20083 {
20084 if (temp2)
20085 delete arg2;
20086 }
20087 return NULL;
20088 }
20089
20090
20091 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj = 0;
20093 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20094 wxString *arg2 = 0 ;
20095 wxConfigBase::EntryType result;
20096 void *argp1 = 0 ;
20097 int res1 = 0 ;
20098 bool temp2 = false ;
20099 PyObject * obj0 = 0 ;
20100 PyObject * obj1 = 0 ;
20101 char * kwnames[] = {
20102 (char *) "self",(char *) "name", NULL
20103 };
20104
20105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20107 if (!SWIG_IsOK(res1)) {
20108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20109 }
20110 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20111 {
20112 arg2 = wxString_in_helper(obj1);
20113 if (arg2 == NULL) SWIG_fail;
20114 temp2 = true;
20115 }
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 resultobj = SWIG_From_int(static_cast< int >(result));
20123 {
20124 if (temp2)
20125 delete arg2;
20126 }
20127 return resultobj;
20128 fail:
20129 {
20130 if (temp2)
20131 delete arg2;
20132 }
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj = 0;
20139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20140 wxString *arg2 = 0 ;
20141 wxString const &arg3_defvalue = wxPyEmptyString ;
20142 wxString *arg3 = (wxString *) &arg3_defvalue ;
20143 wxString result;
20144 void *argp1 = 0 ;
20145 int res1 = 0 ;
20146 bool temp2 = false ;
20147 bool temp3 = false ;
20148 PyObject * obj0 = 0 ;
20149 PyObject * obj1 = 0 ;
20150 PyObject * obj2 = 0 ;
20151 char * kwnames[] = {
20152 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20153 };
20154
20155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20159 }
20160 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20161 {
20162 arg2 = wxString_in_helper(obj1);
20163 if (arg2 == NULL) SWIG_fail;
20164 temp2 = true;
20165 }
20166 if (obj2) {
20167 {
20168 arg3 = wxString_in_helper(obj2);
20169 if (arg3 == NULL) SWIG_fail;
20170 temp3 = true;
20171 }
20172 }
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 {
20180 #if wxUSE_UNICODE
20181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20182 #else
20183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20184 #endif
20185 }
20186 {
20187 if (temp2)
20188 delete arg2;
20189 }
20190 {
20191 if (temp3)
20192 delete arg3;
20193 }
20194 return resultobj;
20195 fail:
20196 {
20197 if (temp2)
20198 delete arg2;
20199 }
20200 {
20201 if (temp3)
20202 delete arg3;
20203 }
20204 return NULL;
20205 }
20206
20207
20208 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20209 PyObject *resultobj = 0;
20210 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20211 wxString *arg2 = 0 ;
20212 long arg3 = (long) 0 ;
20213 long result;
20214 void *argp1 = 0 ;
20215 int res1 = 0 ;
20216 bool temp2 = false ;
20217 long val3 ;
20218 int ecode3 = 0 ;
20219 PyObject * obj0 = 0 ;
20220 PyObject * obj1 = 0 ;
20221 PyObject * obj2 = 0 ;
20222 char * kwnames[] = {
20223 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20224 };
20225
20226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20228 if (!SWIG_IsOK(res1)) {
20229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20230 }
20231 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20232 {
20233 arg2 = wxString_in_helper(obj1);
20234 if (arg2 == NULL) SWIG_fail;
20235 temp2 = true;
20236 }
20237 if (obj2) {
20238 ecode3 = SWIG_AsVal_long(obj2, &val3);
20239 if (!SWIG_IsOK(ecode3)) {
20240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20241 }
20242 arg3 = static_cast< long >(val3);
20243 }
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20247 wxPyEndAllowThreads(__tstate);
20248 if (PyErr_Occurred()) SWIG_fail;
20249 }
20250 resultobj = SWIG_From_long(static_cast< long >(result));
20251 {
20252 if (temp2)
20253 delete arg2;
20254 }
20255 return resultobj;
20256 fail:
20257 {
20258 if (temp2)
20259 delete arg2;
20260 }
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20266 PyObject *resultobj = 0;
20267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20268 wxString *arg2 = 0 ;
20269 double arg3 = (double) 0.0 ;
20270 double result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 bool temp2 = false ;
20274 double val3 ;
20275 int ecode3 = 0 ;
20276 PyObject * obj0 = 0 ;
20277 PyObject * obj1 = 0 ;
20278 PyObject * obj2 = 0 ;
20279 char * kwnames[] = {
20280 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20281 };
20282
20283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20285 if (!SWIG_IsOK(res1)) {
20286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20287 }
20288 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20289 {
20290 arg2 = wxString_in_helper(obj1);
20291 if (arg2 == NULL) SWIG_fail;
20292 temp2 = true;
20293 }
20294 if (obj2) {
20295 ecode3 = SWIG_AsVal_double(obj2, &val3);
20296 if (!SWIG_IsOK(ecode3)) {
20297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20298 }
20299 arg3 = static_cast< double >(val3);
20300 }
20301 {
20302 PyThreadState* __tstate = wxPyBeginAllowThreads();
20303 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_From_double(static_cast< double >(result));
20308 {
20309 if (temp2)
20310 delete arg2;
20311 }
20312 return resultobj;
20313 fail:
20314 {
20315 if (temp2)
20316 delete arg2;
20317 }
20318 return NULL;
20319 }
20320
20321
20322 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20323 PyObject *resultobj = 0;
20324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20325 wxString *arg2 = 0 ;
20326 bool arg3 = (bool) false ;
20327 bool result;
20328 void *argp1 = 0 ;
20329 int res1 = 0 ;
20330 bool temp2 = false ;
20331 bool val3 ;
20332 int ecode3 = 0 ;
20333 PyObject * obj0 = 0 ;
20334 PyObject * obj1 = 0 ;
20335 PyObject * obj2 = 0 ;
20336 char * kwnames[] = {
20337 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20338 };
20339
20340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20344 }
20345 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20346 {
20347 arg2 = wxString_in_helper(obj1);
20348 if (arg2 == NULL) SWIG_fail;
20349 temp2 = true;
20350 }
20351 if (obj2) {
20352 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20353 if (!SWIG_IsOK(ecode3)) {
20354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20355 }
20356 arg3 = static_cast< bool >(val3);
20357 }
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 {
20368 if (temp2)
20369 delete arg2;
20370 }
20371 return resultobj;
20372 fail:
20373 {
20374 if (temp2)
20375 delete arg2;
20376 }
20377 return NULL;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20382 PyObject *resultobj = 0;
20383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20384 wxString *arg2 = 0 ;
20385 wxString *arg3 = 0 ;
20386 bool result;
20387 void *argp1 = 0 ;
20388 int res1 = 0 ;
20389 bool temp2 = false ;
20390 bool temp3 = false ;
20391 PyObject * obj0 = 0 ;
20392 PyObject * obj1 = 0 ;
20393 PyObject * obj2 = 0 ;
20394 char * kwnames[] = {
20395 (char *) "self",(char *) "key",(char *) "value", NULL
20396 };
20397
20398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20400 if (!SWIG_IsOK(res1)) {
20401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20402 }
20403 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20404 {
20405 arg2 = wxString_in_helper(obj1);
20406 if (arg2 == NULL) SWIG_fail;
20407 temp2 = true;
20408 }
20409 {
20410 arg3 = wxString_in_helper(obj2);
20411 if (arg3 == NULL) SWIG_fail;
20412 temp3 = true;
20413 }
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 {
20421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20422 }
20423 {
20424 if (temp2)
20425 delete arg2;
20426 }
20427 {
20428 if (temp3)
20429 delete arg3;
20430 }
20431 return resultobj;
20432 fail:
20433 {
20434 if (temp2)
20435 delete arg2;
20436 }
20437 {
20438 if (temp3)
20439 delete arg3;
20440 }
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj = 0;
20447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20448 wxString *arg2 = 0 ;
20449 long arg3 ;
20450 bool result;
20451 void *argp1 = 0 ;
20452 int res1 = 0 ;
20453 bool temp2 = false ;
20454 long val3 ;
20455 int ecode3 = 0 ;
20456 PyObject * obj0 = 0 ;
20457 PyObject * obj1 = 0 ;
20458 PyObject * obj2 = 0 ;
20459 char * kwnames[] = {
20460 (char *) "self",(char *) "key",(char *) "value", NULL
20461 };
20462
20463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20465 if (!SWIG_IsOK(res1)) {
20466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20467 }
20468 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20469 {
20470 arg2 = wxString_in_helper(obj1);
20471 if (arg2 == NULL) SWIG_fail;
20472 temp2 = true;
20473 }
20474 ecode3 = SWIG_AsVal_long(obj2, &val3);
20475 if (!SWIG_IsOK(ecode3)) {
20476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20477 }
20478 arg3 = static_cast< long >(val3);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20487 }
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return resultobj;
20493 fail:
20494 {
20495 if (temp2)
20496 delete arg2;
20497 }
20498 return NULL;
20499 }
20500
20501
20502 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20503 PyObject *resultobj = 0;
20504 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20505 wxString *arg2 = 0 ;
20506 double arg3 ;
20507 bool result;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 bool temp2 = false ;
20511 double val3 ;
20512 int ecode3 = 0 ;
20513 PyObject * obj0 = 0 ;
20514 PyObject * obj1 = 0 ;
20515 PyObject * obj2 = 0 ;
20516 char * kwnames[] = {
20517 (char *) "self",(char *) "key",(char *) "value", NULL
20518 };
20519
20520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20524 }
20525 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20526 {
20527 arg2 = wxString_in_helper(obj1);
20528 if (arg2 == NULL) SWIG_fail;
20529 temp2 = true;
20530 }
20531 ecode3 = SWIG_AsVal_double(obj2, &val3);
20532 if (!SWIG_IsOK(ecode3)) {
20533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20534 }
20535 arg3 = static_cast< double >(val3);
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 {
20543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20544 }
20545 {
20546 if (temp2)
20547 delete arg2;
20548 }
20549 return resultobj;
20550 fail:
20551 {
20552 if (temp2)
20553 delete arg2;
20554 }
20555 return NULL;
20556 }
20557
20558
20559 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20560 PyObject *resultobj = 0;
20561 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20562 wxString *arg2 = 0 ;
20563 bool arg3 ;
20564 bool result;
20565 void *argp1 = 0 ;
20566 int res1 = 0 ;
20567 bool temp2 = false ;
20568 bool val3 ;
20569 int ecode3 = 0 ;
20570 PyObject * obj0 = 0 ;
20571 PyObject * obj1 = 0 ;
20572 PyObject * obj2 = 0 ;
20573 char * kwnames[] = {
20574 (char *) "self",(char *) "key",(char *) "value", NULL
20575 };
20576
20577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20579 if (!SWIG_IsOK(res1)) {
20580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20581 }
20582 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20583 {
20584 arg2 = wxString_in_helper(obj1);
20585 if (arg2 == NULL) SWIG_fail;
20586 temp2 = true;
20587 }
20588 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20589 if (!SWIG_IsOK(ecode3)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20591 }
20592 arg3 = static_cast< bool >(val3);
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 {
20600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20601 }
20602 {
20603 if (temp2)
20604 delete arg2;
20605 }
20606 return resultobj;
20607 fail:
20608 {
20609 if (temp2)
20610 delete arg2;
20611 }
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj = 0;
20618 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20619 bool arg2 = (bool) false ;
20620 bool result;
20621 void *argp1 = 0 ;
20622 int res1 = 0 ;
20623 bool val2 ;
20624 int ecode2 = 0 ;
20625 PyObject * obj0 = 0 ;
20626 PyObject * obj1 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "self",(char *) "currentOnly", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20635 }
20636 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20637 if (obj1) {
20638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20639 if (!SWIG_IsOK(ecode2)) {
20640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20641 }
20642 arg2 = static_cast< bool >(val2);
20643 }
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (bool)(arg1)->Flush(arg2);
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20660 PyObject *resultobj = 0;
20661 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20662 wxString *arg2 = 0 ;
20663 wxString *arg3 = 0 ;
20664 bool result;
20665 void *argp1 = 0 ;
20666 int res1 = 0 ;
20667 bool temp2 = false ;
20668 bool temp3 = false ;
20669 PyObject * obj0 = 0 ;
20670 PyObject * obj1 = 0 ;
20671 PyObject * obj2 = 0 ;
20672 char * kwnames[] = {
20673 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20674 };
20675
20676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20678 if (!SWIG_IsOK(res1)) {
20679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20680 }
20681 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20682 {
20683 arg2 = wxString_in_helper(obj1);
20684 if (arg2 == NULL) SWIG_fail;
20685 temp2 = true;
20686 }
20687 {
20688 arg3 = wxString_in_helper(obj2);
20689 if (arg3 == NULL) SWIG_fail;
20690 temp3 = true;
20691 }
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 {
20699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20700 }
20701 {
20702 if (temp2)
20703 delete arg2;
20704 }
20705 {
20706 if (temp3)
20707 delete arg3;
20708 }
20709 return resultobj;
20710 fail:
20711 {
20712 if (temp2)
20713 delete arg2;
20714 }
20715 {
20716 if (temp3)
20717 delete arg3;
20718 }
20719 return NULL;
20720 }
20721
20722
20723 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20724 PyObject *resultobj = 0;
20725 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20726 wxString *arg2 = 0 ;
20727 wxString *arg3 = 0 ;
20728 bool result;
20729 void *argp1 = 0 ;
20730 int res1 = 0 ;
20731 bool temp2 = false ;
20732 bool temp3 = false ;
20733 PyObject * obj0 = 0 ;
20734 PyObject * obj1 = 0 ;
20735 PyObject * obj2 = 0 ;
20736 char * kwnames[] = {
20737 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20738 };
20739
20740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20744 }
20745 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20746 {
20747 arg2 = wxString_in_helper(obj1);
20748 if (arg2 == NULL) SWIG_fail;
20749 temp2 = true;
20750 }
20751 {
20752 arg3 = wxString_in_helper(obj2);
20753 if (arg3 == NULL) SWIG_fail;
20754 temp3 = true;
20755 }
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 {
20763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20764 }
20765 {
20766 if (temp2)
20767 delete arg2;
20768 }
20769 {
20770 if (temp3)
20771 delete arg3;
20772 }
20773 return resultobj;
20774 fail:
20775 {
20776 if (temp2)
20777 delete arg2;
20778 }
20779 {
20780 if (temp3)
20781 delete arg3;
20782 }
20783 return NULL;
20784 }
20785
20786
20787 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20788 PyObject *resultobj = 0;
20789 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20790 wxString *arg2 = 0 ;
20791 bool arg3 = (bool) true ;
20792 bool result;
20793 void *argp1 = 0 ;
20794 int res1 = 0 ;
20795 bool temp2 = false ;
20796 bool val3 ;
20797 int ecode3 = 0 ;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 PyObject * obj2 = 0 ;
20801 char * kwnames[] = {
20802 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20803 };
20804
20805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20807 if (!SWIG_IsOK(res1)) {
20808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20809 }
20810 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20811 {
20812 arg2 = wxString_in_helper(obj1);
20813 if (arg2 == NULL) SWIG_fail;
20814 temp2 = true;
20815 }
20816 if (obj2) {
20817 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20818 if (!SWIG_IsOK(ecode3)) {
20819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20820 }
20821 arg3 = static_cast< bool >(val3);
20822 }
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 {
20830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20831 }
20832 {
20833 if (temp2)
20834 delete arg2;
20835 }
20836 return resultobj;
20837 fail:
20838 {
20839 if (temp2)
20840 delete arg2;
20841 }
20842 return NULL;
20843 }
20844
20845
20846 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj = 0;
20848 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20849 wxString *arg2 = 0 ;
20850 bool result;
20851 void *argp1 = 0 ;
20852 int res1 = 0 ;
20853 bool temp2 = false ;
20854 PyObject * obj0 = 0 ;
20855 PyObject * obj1 = 0 ;
20856 char * kwnames[] = {
20857 (char *) "self",(char *) "key", NULL
20858 };
20859
20860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20864 }
20865 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20866 {
20867 arg2 = wxString_in_helper(obj1);
20868 if (arg2 == NULL) SWIG_fail;
20869 temp2 = true;
20870 }
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 {
20878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20879 }
20880 {
20881 if (temp2)
20882 delete arg2;
20883 }
20884 return resultobj;
20885 fail:
20886 {
20887 if (temp2)
20888 delete arg2;
20889 }
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20895 PyObject *resultobj = 0;
20896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20897 bool result;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 PyObject *swig_obj[1] ;
20901
20902 if (!args) SWIG_fail;
20903 swig_obj[0] = args;
20904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20907 }
20908 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)(arg1)->DeleteAll();
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 {
20916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj = 0;
20926 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20927 bool arg2 = (bool) true ;
20928 void *argp1 = 0 ;
20929 int res1 = 0 ;
20930 bool val2 ;
20931 int ecode2 = 0 ;
20932 PyObject * obj0 = 0 ;
20933 PyObject * obj1 = 0 ;
20934 char * kwnames[] = {
20935 (char *) "self",(char *) "doIt", NULL
20936 };
20937
20938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20942 }
20943 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20944 if (obj1) {
20945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20946 if (!SWIG_IsOK(ecode2)) {
20947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20948 }
20949 arg2 = static_cast< bool >(val2);
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 (arg1)->SetExpandEnvVars(arg2);
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 resultobj = SWIG_Py_Void();
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20965 PyObject *resultobj = 0;
20966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20967 bool result;
20968 void *argp1 = 0 ;
20969 int res1 = 0 ;
20970 PyObject *swig_obj[1] ;
20971
20972 if (!args) SWIG_fail;
20973 swig_obj[0] = args;
20974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20975 if (!SWIG_IsOK(res1)) {
20976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20977 }
20978 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20982 wxPyEndAllowThreads(__tstate);
20983 if (PyErr_Occurred()) SWIG_fail;
20984 }
20985 {
20986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj = 0;
20996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20997 bool arg2 = (bool) true ;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 bool val2 ;
21001 int ecode2 = 0 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char * kwnames[] = {
21005 (char *) "self",(char *) "doIt", NULL
21006 };
21007
21008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21010 if (!SWIG_IsOK(res1)) {
21011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21012 }
21013 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21014 if (obj1) {
21015 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21016 if (!SWIG_IsOK(ecode2)) {
21017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21018 }
21019 arg2 = static_cast< bool >(val2);
21020 }
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 (arg1)->SetRecordDefaults(arg2);
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 resultobj = SWIG_Py_Void();
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21035 PyObject *resultobj = 0;
21036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21037 bool result;
21038 void *argp1 = 0 ;
21039 int res1 = 0 ;
21040 PyObject *swig_obj[1] ;
21041
21042 if (!args) SWIG_fail;
21043 swig_obj[0] = args;
21044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21047 }
21048 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 {
21056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21057 }
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21065 PyObject *resultobj = 0;
21066 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21067 wxString *arg2 = 0 ;
21068 wxString result;
21069 void *argp1 = 0 ;
21070 int res1 = 0 ;
21071 bool temp2 = false ;
21072 PyObject * obj0 = 0 ;
21073 PyObject * obj1 = 0 ;
21074 char * kwnames[] = {
21075 (char *) "self",(char *) "str", NULL
21076 };
21077
21078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21082 }
21083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21084 {
21085 arg2 = wxString_in_helper(obj1);
21086 if (arg2 == NULL) SWIG_fail;
21087 temp2 = true;
21088 }
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21092 wxPyEndAllowThreads(__tstate);
21093 if (PyErr_Occurred()) SWIG_fail;
21094 }
21095 {
21096 #if wxUSE_UNICODE
21097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21098 #else
21099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21100 #endif
21101 }
21102 {
21103 if (temp2)
21104 delete arg2;
21105 }
21106 return resultobj;
21107 fail:
21108 {
21109 if (temp2)
21110 delete arg2;
21111 }
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21117 PyObject *resultobj = 0;
21118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21119 wxString result;
21120 void *argp1 = 0 ;
21121 int res1 = 0 ;
21122 PyObject *swig_obj[1] ;
21123
21124 if (!args) SWIG_fail;
21125 swig_obj[0] = args;
21126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21127 if (!SWIG_IsOK(res1)) {
21128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21129 }
21130 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 result = ((wxConfigBase const *)arg1)->GetAppName();
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 {
21138 #if wxUSE_UNICODE
21139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21140 #else
21141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21142 #endif
21143 }
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21151 PyObject *resultobj = 0;
21152 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21153 wxString result;
21154 void *argp1 = 0 ;
21155 int res1 = 0 ;
21156 PyObject *swig_obj[1] ;
21157
21158 if (!args) SWIG_fail;
21159 swig_obj[0] = args;
21160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21163 }
21164 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 result = ((wxConfigBase const *)arg1)->GetVendorName();
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 {
21172 #if wxUSE_UNICODE
21173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21174 #else
21175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21176 #endif
21177 }
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj = 0;
21186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21187 wxString *arg2 = 0 ;
21188 void *argp1 = 0 ;
21189 int res1 = 0 ;
21190 bool temp2 = false ;
21191 PyObject * obj0 = 0 ;
21192 PyObject * obj1 = 0 ;
21193 char * kwnames[] = {
21194 (char *) "self",(char *) "appName", NULL
21195 };
21196
21197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21199 if (!SWIG_IsOK(res1)) {
21200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21201 }
21202 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21203 {
21204 arg2 = wxString_in_helper(obj1);
21205 if (arg2 == NULL) SWIG_fail;
21206 temp2 = true;
21207 }
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 (arg1)->SetAppName((wxString const &)*arg2);
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 resultobj = SWIG_Py_Void();
21215 {
21216 if (temp2)
21217 delete arg2;
21218 }
21219 return resultobj;
21220 fail:
21221 {
21222 if (temp2)
21223 delete arg2;
21224 }
21225 return NULL;
21226 }
21227
21228
21229 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21230 PyObject *resultobj = 0;
21231 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21232 wxString *arg2 = 0 ;
21233 void *argp1 = 0 ;
21234 int res1 = 0 ;
21235 bool temp2 = false ;
21236 PyObject * obj0 = 0 ;
21237 PyObject * obj1 = 0 ;
21238 char * kwnames[] = {
21239 (char *) "self",(char *) "vendorName", NULL
21240 };
21241
21242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21244 if (!SWIG_IsOK(res1)) {
21245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21246 }
21247 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21248 {
21249 arg2 = wxString_in_helper(obj1);
21250 if (arg2 == NULL) SWIG_fail;
21251 temp2 = true;
21252 }
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 (arg1)->SetVendorName((wxString const &)*arg2);
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_Py_Void();
21260 {
21261 if (temp2)
21262 delete arg2;
21263 }
21264 return resultobj;
21265 fail:
21266 {
21267 if (temp2)
21268 delete arg2;
21269 }
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj = 0;
21276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21277 long arg2 ;
21278 void *argp1 = 0 ;
21279 int res1 = 0 ;
21280 long val2 ;
21281 int ecode2 = 0 ;
21282 PyObject * obj0 = 0 ;
21283 PyObject * obj1 = 0 ;
21284 char * kwnames[] = {
21285 (char *) "self",(char *) "style", NULL
21286 };
21287
21288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21292 }
21293 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21294 ecode2 = SWIG_AsVal_long(obj1, &val2);
21295 if (!SWIG_IsOK(ecode2)) {
21296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21297 }
21298 arg2 = static_cast< long >(val2);
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 (arg1)->SetStyle(arg2);
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 resultobj = SWIG_Py_Void();
21306 return resultobj;
21307 fail:
21308 return NULL;
21309 }
21310
21311
21312 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21313 PyObject *resultobj = 0;
21314 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21315 long result;
21316 void *argp1 = 0 ;
21317 int res1 = 0 ;
21318 PyObject *swig_obj[1] ;
21319
21320 if (!args) SWIG_fail;
21321 swig_obj[0] = args;
21322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21323 if (!SWIG_IsOK(res1)) {
21324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21325 }
21326 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21327 {
21328 PyThreadState* __tstate = wxPyBeginAllowThreads();
21329 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21330 wxPyEndAllowThreads(__tstate);
21331 if (PyErr_Occurred()) SWIG_fail;
21332 }
21333 resultobj = SWIG_From_long(static_cast< long >(result));
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21341 PyObject *obj;
21342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21343 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21344 return SWIG_Py_Void();
21345 }
21346
21347 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj = 0;
21349 wxString const &arg1_defvalue = wxPyEmptyString ;
21350 wxString *arg1 = (wxString *) &arg1_defvalue ;
21351 wxString const &arg2_defvalue = wxPyEmptyString ;
21352 wxString *arg2 = (wxString *) &arg2_defvalue ;
21353 wxString const &arg3_defvalue = wxPyEmptyString ;
21354 wxString *arg3 = (wxString *) &arg3_defvalue ;
21355 wxString const &arg4_defvalue = wxPyEmptyString ;
21356 wxString *arg4 = (wxString *) &arg4_defvalue ;
21357 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21358 wxConfig *result = 0 ;
21359 bool temp1 = false ;
21360 bool temp2 = false ;
21361 bool temp3 = false ;
21362 bool temp4 = false ;
21363 long val5 ;
21364 int ecode5 = 0 ;
21365 PyObject * obj0 = 0 ;
21366 PyObject * obj1 = 0 ;
21367 PyObject * obj2 = 0 ;
21368 PyObject * obj3 = 0 ;
21369 PyObject * obj4 = 0 ;
21370 char * kwnames[] = {
21371 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21372 };
21373
21374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21375 if (obj0) {
21376 {
21377 arg1 = wxString_in_helper(obj0);
21378 if (arg1 == NULL) SWIG_fail;
21379 temp1 = true;
21380 }
21381 }
21382 if (obj1) {
21383 {
21384 arg2 = wxString_in_helper(obj1);
21385 if (arg2 == NULL) SWIG_fail;
21386 temp2 = true;
21387 }
21388 }
21389 if (obj2) {
21390 {
21391 arg3 = wxString_in_helper(obj2);
21392 if (arg3 == NULL) SWIG_fail;
21393 temp3 = true;
21394 }
21395 }
21396 if (obj3) {
21397 {
21398 arg4 = wxString_in_helper(obj3);
21399 if (arg4 == NULL) SWIG_fail;
21400 temp4 = true;
21401 }
21402 }
21403 if (obj4) {
21404 ecode5 = SWIG_AsVal_long(obj4, &val5);
21405 if (!SWIG_IsOK(ecode5)) {
21406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21407 }
21408 arg5 = static_cast< long >(val5);
21409 }
21410 {
21411 PyThreadState* __tstate = wxPyBeginAllowThreads();
21412 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21413 wxPyEndAllowThreads(__tstate);
21414 if (PyErr_Occurred()) SWIG_fail;
21415 }
21416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21417 {
21418 if (temp1)
21419 delete arg1;
21420 }
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 {
21426 if (temp3)
21427 delete arg3;
21428 }
21429 {
21430 if (temp4)
21431 delete arg4;
21432 }
21433 return resultobj;
21434 fail:
21435 {
21436 if (temp1)
21437 delete arg1;
21438 }
21439 {
21440 if (temp2)
21441 delete arg2;
21442 }
21443 {
21444 if (temp3)
21445 delete arg3;
21446 }
21447 {
21448 if (temp4)
21449 delete arg4;
21450 }
21451 return NULL;
21452 }
21453
21454
21455 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21456 PyObject *resultobj = 0;
21457 wxConfig *arg1 = (wxConfig *) 0 ;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 PyObject *swig_obj[1] ;
21461
21462 if (!args) SWIG_fail;
21463 swig_obj[0] = args;
21464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21467 }
21468 arg1 = reinterpret_cast< wxConfig * >(argp1);
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 delete arg1;
21472
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 resultobj = SWIG_Py_Void();
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *obj;
21485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21486 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21487 return SWIG_Py_Void();
21488 }
21489
21490 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21491 return SWIG_Python_InitShadowInstance(args);
21492 }
21493
21494 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj = 0;
21496 wxString const &arg1_defvalue = wxPyEmptyString ;
21497 wxString *arg1 = (wxString *) &arg1_defvalue ;
21498 wxString const &arg2_defvalue = wxPyEmptyString ;
21499 wxString *arg2 = (wxString *) &arg2_defvalue ;
21500 wxString const &arg3_defvalue = wxPyEmptyString ;
21501 wxString *arg3 = (wxString *) &arg3_defvalue ;
21502 wxString const &arg4_defvalue = wxPyEmptyString ;
21503 wxString *arg4 = (wxString *) &arg4_defvalue ;
21504 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21505 wxFileConfig *result = 0 ;
21506 bool temp1 = false ;
21507 bool temp2 = false ;
21508 bool temp3 = false ;
21509 bool temp4 = false ;
21510 long val5 ;
21511 int ecode5 = 0 ;
21512 PyObject * obj0 = 0 ;
21513 PyObject * obj1 = 0 ;
21514 PyObject * obj2 = 0 ;
21515 PyObject * obj3 = 0 ;
21516 PyObject * obj4 = 0 ;
21517 char * kwnames[] = {
21518 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21519 };
21520
21521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21522 if (obj0) {
21523 {
21524 arg1 = wxString_in_helper(obj0);
21525 if (arg1 == NULL) SWIG_fail;
21526 temp1 = true;
21527 }
21528 }
21529 if (obj1) {
21530 {
21531 arg2 = wxString_in_helper(obj1);
21532 if (arg2 == NULL) SWIG_fail;
21533 temp2 = true;
21534 }
21535 }
21536 if (obj2) {
21537 {
21538 arg3 = wxString_in_helper(obj2);
21539 if (arg3 == NULL) SWIG_fail;
21540 temp3 = true;
21541 }
21542 }
21543 if (obj3) {
21544 {
21545 arg4 = wxString_in_helper(obj3);
21546 if (arg4 == NULL) SWIG_fail;
21547 temp4 = true;
21548 }
21549 }
21550 if (obj4) {
21551 ecode5 = SWIG_AsVal_long(obj4, &val5);
21552 if (!SWIG_IsOK(ecode5)) {
21553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21554 }
21555 arg5 = static_cast< long >(val5);
21556 }
21557 {
21558 PyThreadState* __tstate = wxPyBeginAllowThreads();
21559 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21564 {
21565 if (temp1)
21566 delete arg1;
21567 }
21568 {
21569 if (temp2)
21570 delete arg2;
21571 }
21572 {
21573 if (temp3)
21574 delete arg3;
21575 }
21576 {
21577 if (temp4)
21578 delete arg4;
21579 }
21580 return resultobj;
21581 fail:
21582 {
21583 if (temp1)
21584 delete arg1;
21585 }
21586 {
21587 if (temp2)
21588 delete arg2;
21589 }
21590 {
21591 if (temp3)
21592 delete arg3;
21593 }
21594 {
21595 if (temp4)
21596 delete arg4;
21597 }
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21603 PyObject *resultobj = 0;
21604 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 PyObject *swig_obj[1] ;
21608
21609 if (!args) SWIG_fail;
21610 swig_obj[0] = args;
21611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21612 if (!SWIG_IsOK(res1)) {
21613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21614 }
21615 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21616 {
21617 PyThreadState* __tstate = wxPyBeginAllowThreads();
21618 delete arg1;
21619
21620 wxPyEndAllowThreads(__tstate);
21621 if (PyErr_Occurred()) SWIG_fail;
21622 }
21623 resultobj = SWIG_Py_Void();
21624 return resultobj;
21625 fail:
21626 return NULL;
21627 }
21628
21629
21630 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21631 PyObject *obj;
21632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21633 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21634 return SWIG_Py_Void();
21635 }
21636
21637 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 return SWIG_Python_InitShadowInstance(args);
21639 }
21640
21641 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj = 0;
21643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21644 wxString *arg2 = 0 ;
21645 wxConfigPathChanger *result = 0 ;
21646 void *argp1 = 0 ;
21647 int res1 = 0 ;
21648 bool temp2 = false ;
21649 PyObject * obj0 = 0 ;
21650 PyObject * obj1 = 0 ;
21651 char * kwnames[] = {
21652 (char *) "config",(char *) "entry", NULL
21653 };
21654
21655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21657 if (!SWIG_IsOK(res1)) {
21658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21659 }
21660 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21661 {
21662 arg2 = wxString_in_helper(obj1);
21663 if (arg2 == NULL) SWIG_fail;
21664 temp2 = true;
21665 }
21666 {
21667 PyThreadState* __tstate = wxPyBeginAllowThreads();
21668 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21669 wxPyEndAllowThreads(__tstate);
21670 if (PyErr_Occurred()) SWIG_fail;
21671 }
21672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21673 {
21674 if (temp2)
21675 delete arg2;
21676 }
21677 return resultobj;
21678 fail:
21679 {
21680 if (temp2)
21681 delete arg2;
21682 }
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21690 void *argp1 = 0 ;
21691 int res1 = 0 ;
21692 PyObject *swig_obj[1] ;
21693
21694 if (!args) SWIG_fail;
21695 swig_obj[0] = args;
21696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21697 if (!SWIG_IsOK(res1)) {
21698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21699 }
21700 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21701 {
21702 PyThreadState* __tstate = wxPyBeginAllowThreads();
21703 delete arg1;
21704
21705 wxPyEndAllowThreads(__tstate);
21706 if (PyErr_Occurred()) SWIG_fail;
21707 }
21708 resultobj = SWIG_Py_Void();
21709 return resultobj;
21710 fail:
21711 return NULL;
21712 }
21713
21714
21715 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21716 PyObject *resultobj = 0;
21717 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21718 wxString *result = 0 ;
21719 void *argp1 = 0 ;
21720 int res1 = 0 ;
21721 PyObject *swig_obj[1] ;
21722
21723 if (!args) SWIG_fail;
21724 swig_obj[0] = args;
21725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21726 if (!SWIG_IsOK(res1)) {
21727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21728 }
21729 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 {
21733 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21734 result = (wxString *) &_result_ref;
21735 }
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 {
21740 #if wxUSE_UNICODE
21741 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21742 #else
21743 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21744 #endif
21745 }
21746 return resultobj;
21747 fail:
21748 return NULL;
21749 }
21750
21751
21752 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21753 PyObject *obj;
21754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21755 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21756 return SWIG_Py_Void();
21757 }
21758
21759 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21760 return SWIG_Python_InitShadowInstance(args);
21761 }
21762
21763 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21764 PyObject *resultobj = 0;
21765 wxString *arg1 = 0 ;
21766 wxString result;
21767 bool temp1 = false ;
21768 PyObject * obj0 = 0 ;
21769 char * kwnames[] = {
21770 (char *) "sz", NULL
21771 };
21772
21773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21774 {
21775 arg1 = wxString_in_helper(obj0);
21776 if (arg1 == NULL) SWIG_fail;
21777 temp1 = true;
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = wxExpandEnvVars((wxString const &)*arg1);
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 {
21786 #if wxUSE_UNICODE
21787 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21788 #else
21789 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21790 #endif
21791 }
21792 {
21793 if (temp1)
21794 delete arg1;
21795 }
21796 return resultobj;
21797 fail:
21798 {
21799 if (temp1)
21800 delete arg1;
21801 }
21802 return NULL;
21803 }
21804
21805
21806 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21807 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21808 return 1;
21809 }
21810
21811
21812 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21813 PyObject *pyobj = 0;
21814
21815 {
21816 #if wxUSE_UNICODE
21817 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21818 #else
21819 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21820 #endif
21821 }
21822 return pyobj;
21823 }
21824
21825
21826 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21827 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21828 return 1;
21829 }
21830
21831
21832 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21833 PyObject *pyobj = 0;
21834
21835 {
21836 #if wxUSE_UNICODE
21837 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21838 #else
21839 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21840 #endif
21841 }
21842 return pyobj;
21843 }
21844
21845
21846 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21847 PyObject *resultobj = 0;
21848 wxDateTime::Country arg1 ;
21849 int val1 ;
21850 int ecode1 = 0 ;
21851 PyObject * obj0 = 0 ;
21852 char * kwnames[] = {
21853 (char *) "country", NULL
21854 };
21855
21856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21857 ecode1 = SWIG_AsVal_int(obj0, &val1);
21858 if (!SWIG_IsOK(ecode1)) {
21859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21860 }
21861 arg1 = static_cast< wxDateTime::Country >(val1);
21862 {
21863 PyThreadState* __tstate = wxPyBeginAllowThreads();
21864 wxDateTime::SetCountry(arg1);
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 resultobj = SWIG_Py_Void();
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *resultobj = 0;
21877 wxDateTime::Country result;
21878
21879 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (wxDateTime::Country)wxDateTime::GetCountry();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 resultobj = SWIG_From_int(static_cast< int >(result));
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21894 PyObject *resultobj = 0;
21895 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21896 bool result;
21897 int val1 ;
21898 int ecode1 = 0 ;
21899 PyObject * obj0 = 0 ;
21900 char * kwnames[] = {
21901 (char *) "country", NULL
21902 };
21903
21904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21905 if (obj0) {
21906 ecode1 = SWIG_AsVal_int(obj0, &val1);
21907 if (!SWIG_IsOK(ecode1)) {
21908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21909 }
21910 arg1 = static_cast< wxDateTime::Country >(val1);
21911 }
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21928 PyObject *resultobj = 0;
21929 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21930 int result;
21931 int val1 ;
21932 int ecode1 = 0 ;
21933 PyObject * obj0 = 0 ;
21934 char * kwnames[] = {
21935 (char *) "cal", NULL
21936 };
21937
21938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21939 if (obj0) {
21940 ecode1 = SWIG_AsVal_int(obj0, &val1);
21941 if (!SWIG_IsOK(ecode1)) {
21942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21943 }
21944 arg1 = static_cast< wxDateTime::Calendar >(val1);
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (int)wxDateTime::GetCurrentYear(arg1);
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 resultobj = SWIG_From_int(static_cast< int >(result));
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21960 PyObject *resultobj = 0;
21961 int arg1 ;
21962 int result;
21963 int val1 ;
21964 int ecode1 = 0 ;
21965 PyObject * obj0 = 0 ;
21966 char * kwnames[] = {
21967 (char *) "year", NULL
21968 };
21969
21970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21971 ecode1 = SWIG_AsVal_int(obj0, &val1);
21972 if (!SWIG_IsOK(ecode1)) {
21973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21974 }
21975 arg1 = static_cast< int >(val1);
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 result = (int)wxDateTime::ConvertYearToBC(arg1);
21979 wxPyEndAllowThreads(__tstate);
21980 if (PyErr_Occurred()) SWIG_fail;
21981 }
21982 resultobj = SWIG_From_int(static_cast< int >(result));
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21990 PyObject *resultobj = 0;
21991 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21992 wxDateTime::Month result;
21993 int val1 ;
21994 int ecode1 = 0 ;
21995 PyObject * obj0 = 0 ;
21996 char * kwnames[] = {
21997 (char *) "cal", NULL
21998 };
21999
22000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22001 if (obj0) {
22002 ecode1 = SWIG_AsVal_int(obj0, &val1);
22003 if (!SWIG_IsOK(ecode1)) {
22004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22005 }
22006 arg1 = static_cast< wxDateTime::Calendar >(val1);
22007 }
22008 {
22009 PyThreadState* __tstate = wxPyBeginAllowThreads();
22010 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 resultobj = SWIG_From_int(static_cast< int >(result));
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj = 0;
22023 int arg1 = (int) wxDateTime::Inv_Year ;
22024 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22025 bool result;
22026 int val1 ;
22027 int ecode1 = 0 ;
22028 int val2 ;
22029 int ecode2 = 0 ;
22030 PyObject * obj0 = 0 ;
22031 PyObject * obj1 = 0 ;
22032 char * kwnames[] = {
22033 (char *) "year",(char *) "cal", NULL
22034 };
22035
22036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22037 if (obj0) {
22038 ecode1 = SWIG_AsVal_int(obj0, &val1);
22039 if (!SWIG_IsOK(ecode1)) {
22040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22041 }
22042 arg1 = static_cast< int >(val1);
22043 }
22044 if (obj1) {
22045 ecode2 = SWIG_AsVal_int(obj1, &val2);
22046 if (!SWIG_IsOK(ecode2)) {
22047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22048 }
22049 arg2 = static_cast< wxDateTime::Calendar >(val2);
22050 }
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22067 PyObject *resultobj = 0;
22068 int arg1 = (int) wxDateTime::Inv_Year ;
22069 int result;
22070 int val1 ;
22071 int ecode1 = 0 ;
22072 PyObject * obj0 = 0 ;
22073 char * kwnames[] = {
22074 (char *) "year", NULL
22075 };
22076
22077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22078 if (obj0) {
22079 ecode1 = SWIG_AsVal_int(obj0, &val1);
22080 if (!SWIG_IsOK(ecode1)) {
22081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22082 }
22083 arg1 = static_cast< int >(val1);
22084 }
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (int)wxDateTime::GetCentury(arg1);
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 resultobj = SWIG_From_int(static_cast< int >(result));
22092 return resultobj;
22093 fail:
22094 return NULL;
22095 }
22096
22097
22098 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj = 0;
22100 int arg1 ;
22101 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22102 int result;
22103 int val1 ;
22104 int ecode1 = 0 ;
22105 int val2 ;
22106 int ecode2 = 0 ;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 char * kwnames[] = {
22110 (char *) "year",(char *) "cal", NULL
22111 };
22112
22113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22114 ecode1 = SWIG_AsVal_int(obj0, &val1);
22115 if (!SWIG_IsOK(ecode1)) {
22116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22117 }
22118 arg1 = static_cast< int >(val1);
22119 if (obj1) {
22120 ecode2 = SWIG_AsVal_int(obj1, &val2);
22121 if (!SWIG_IsOK(ecode2)) {
22122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22123 }
22124 arg2 = static_cast< wxDateTime::Calendar >(val2);
22125 }
22126 {
22127 PyThreadState* __tstate = wxPyBeginAllowThreads();
22128 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 resultobj = SWIG_From_int(static_cast< int >(result));
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj = 0;
22141 wxDateTime::Month arg1 ;
22142 int arg2 = (int) wxDateTime::Inv_Year ;
22143 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22144 int result;
22145 int val1 ;
22146 int ecode1 = 0 ;
22147 int val2 ;
22148 int ecode2 = 0 ;
22149 int val3 ;
22150 int ecode3 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 PyObject * obj2 = 0 ;
22154 char * kwnames[] = {
22155 (char *) "month",(char *) "year",(char *) "cal", NULL
22156 };
22157
22158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22159 ecode1 = SWIG_AsVal_int(obj0, &val1);
22160 if (!SWIG_IsOK(ecode1)) {
22161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22162 }
22163 arg1 = static_cast< wxDateTime::Month >(val1);
22164 if (obj1) {
22165 ecode2 = SWIG_AsVal_int(obj1, &val2);
22166 if (!SWIG_IsOK(ecode2)) {
22167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22168 }
22169 arg2 = static_cast< int >(val2);
22170 }
22171 if (obj2) {
22172 ecode3 = SWIG_AsVal_int(obj2, &val3);
22173 if (!SWIG_IsOK(ecode3)) {
22174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22175 }
22176 arg3 = static_cast< wxDateTime::Calendar >(val3);
22177 }
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 resultobj = SWIG_From_int(static_cast< int >(result));
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj = 0;
22193 wxDateTime::Month arg1 ;
22194 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22195 wxString result;
22196 int val1 ;
22197 int ecode1 = 0 ;
22198 int val2 ;
22199 int ecode2 = 0 ;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char * kwnames[] = {
22203 (char *) "month",(char *) "flags", NULL
22204 };
22205
22206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22207 ecode1 = SWIG_AsVal_int(obj0, &val1);
22208 if (!SWIG_IsOK(ecode1)) {
22209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22210 }
22211 arg1 = static_cast< wxDateTime::Month >(val1);
22212 if (obj1) {
22213 ecode2 = SWIG_AsVal_int(obj1, &val2);
22214 if (!SWIG_IsOK(ecode2)) {
22215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22216 }
22217 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22218 }
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = wxDateTime::GetMonthName(arg1,arg2);
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 {
22226 #if wxUSE_UNICODE
22227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22228 #else
22229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22230 #endif
22231 }
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22239 PyObject *resultobj = 0;
22240 wxDateTime::WeekDay arg1 ;
22241 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22242 wxString result;
22243 int val1 ;
22244 int ecode1 = 0 ;
22245 int val2 ;
22246 int ecode2 = 0 ;
22247 PyObject * obj0 = 0 ;
22248 PyObject * obj1 = 0 ;
22249 char * kwnames[] = {
22250 (char *) "weekday",(char *) "flags", NULL
22251 };
22252
22253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22254 ecode1 = SWIG_AsVal_int(obj0, &val1);
22255 if (!SWIG_IsOK(ecode1)) {
22256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22257 }
22258 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22259 if (obj1) {
22260 ecode2 = SWIG_AsVal_int(obj1, &val2);
22261 if (!SWIG_IsOK(ecode2)) {
22262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22263 }
22264 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22265 }
22266 {
22267 PyThreadState* __tstate = wxPyBeginAllowThreads();
22268 result = wxDateTime::GetWeekDayName(arg1,arg2);
22269 wxPyEndAllowThreads(__tstate);
22270 if (PyErr_Occurred()) SWIG_fail;
22271 }
22272 {
22273 #if wxUSE_UNICODE
22274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22275 #else
22276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22277 #endif
22278 }
22279 return resultobj;
22280 fail:
22281 return NULL;
22282 }
22283
22284
22285 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22286 PyObject *resultobj = 0;
22287 PyObject *result = 0 ;
22288
22289 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (PyObject *)wxDateTime_GetAmPmStrings();
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 resultobj = result;
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22304 PyObject *resultobj = 0;
22305 int arg1 = (int) wxDateTime::Inv_Year ;
22306 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22307 bool result;
22308 int val1 ;
22309 int ecode1 = 0 ;
22310 int val2 ;
22311 int ecode2 = 0 ;
22312 PyObject * obj0 = 0 ;
22313 PyObject * obj1 = 0 ;
22314 char * kwnames[] = {
22315 (char *) "year",(char *) "country", NULL
22316 };
22317
22318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22319 if (obj0) {
22320 ecode1 = SWIG_AsVal_int(obj0, &val1);
22321 if (!SWIG_IsOK(ecode1)) {
22322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22323 }
22324 arg1 = static_cast< int >(val1);
22325 }
22326 if (obj1) {
22327 ecode2 = SWIG_AsVal_int(obj1, &val2);
22328 if (!SWIG_IsOK(ecode2)) {
22329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22330 }
22331 arg2 = static_cast< wxDateTime::Country >(val2);
22332 }
22333 {
22334 PyThreadState* __tstate = wxPyBeginAllowThreads();
22335 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22336 wxPyEndAllowThreads(__tstate);
22337 if (PyErr_Occurred()) SWIG_fail;
22338 }
22339 {
22340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22341 }
22342 return resultobj;
22343 fail:
22344 return NULL;
22345 }
22346
22347
22348 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22349 PyObject *resultobj = 0;
22350 int arg1 = (int) wxDateTime::Inv_Year ;
22351 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22352 wxDateTime result;
22353 int val1 ;
22354 int ecode1 = 0 ;
22355 int val2 ;
22356 int ecode2 = 0 ;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char * kwnames[] = {
22360 (char *) "year",(char *) "country", NULL
22361 };
22362
22363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22364 if (obj0) {
22365 ecode1 = SWIG_AsVal_int(obj0, &val1);
22366 if (!SWIG_IsOK(ecode1)) {
22367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22368 }
22369 arg1 = static_cast< int >(val1);
22370 }
22371 if (obj1) {
22372 ecode2 = SWIG_AsVal_int(obj1, &val2);
22373 if (!SWIG_IsOK(ecode2)) {
22374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22375 }
22376 arg2 = static_cast< wxDateTime::Country >(val2);
22377 }
22378 {
22379 PyThreadState* __tstate = wxPyBeginAllowThreads();
22380 result = wxDateTime::GetBeginDST(arg1,arg2);
22381 wxPyEndAllowThreads(__tstate);
22382 if (PyErr_Occurred()) SWIG_fail;
22383 }
22384 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj = 0;
22393 int arg1 = (int) wxDateTime::Inv_Year ;
22394 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22395 wxDateTime result;
22396 int val1 ;
22397 int ecode1 = 0 ;
22398 int val2 ;
22399 int ecode2 = 0 ;
22400 PyObject * obj0 = 0 ;
22401 PyObject * obj1 = 0 ;
22402 char * kwnames[] = {
22403 (char *) "year",(char *) "country", NULL
22404 };
22405
22406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22407 if (obj0) {
22408 ecode1 = SWIG_AsVal_int(obj0, &val1);
22409 if (!SWIG_IsOK(ecode1)) {
22410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22411 }
22412 arg1 = static_cast< int >(val1);
22413 }
22414 if (obj1) {
22415 ecode2 = SWIG_AsVal_int(obj1, &val2);
22416 if (!SWIG_IsOK(ecode2)) {
22417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22418 }
22419 arg2 = static_cast< wxDateTime::Country >(val2);
22420 }
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 result = wxDateTime::GetEndDST(arg1,arg2);
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22435 PyObject *resultobj = 0;
22436 wxDateTime result;
22437
22438 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = wxDateTime::Now();
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22453 PyObject *resultobj = 0;
22454 wxDateTime result;
22455
22456 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22457 {
22458 PyThreadState* __tstate = wxPyBeginAllowThreads();
22459 result = wxDateTime::UNow();
22460 wxPyEndAllowThreads(__tstate);
22461 if (PyErr_Occurred()) SWIG_fail;
22462 }
22463 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22471 PyObject *resultobj = 0;
22472 wxDateTime result;
22473
22474 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = wxDateTime::Today();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxDateTime *result = 0 ;
22491
22492 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = (wxDateTime *)new wxDateTime();
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22507 PyObject *resultobj = 0;
22508 time_t arg1 ;
22509 wxDateTime *result = 0 ;
22510 unsigned int val1 ;
22511 int ecode1 = 0 ;
22512 PyObject * obj0 = 0 ;
22513 char * kwnames[] = {
22514 (char *) "timet", NULL
22515 };
22516
22517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22518 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22519 if (!SWIG_IsOK(ecode1)) {
22520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22521 }
22522 arg1 = static_cast< time_t >(val1);
22523 {
22524 PyThreadState* __tstate = wxPyBeginAllowThreads();
22525 result = (wxDateTime *)new wxDateTime(arg1);
22526 wxPyEndAllowThreads(__tstate);
22527 if (PyErr_Occurred()) SWIG_fail;
22528 }
22529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 double arg1 ;
22539 wxDateTime *result = 0 ;
22540 double val1 ;
22541 int ecode1 = 0 ;
22542 PyObject * obj0 = 0 ;
22543 char * kwnames[] = {
22544 (char *) "jdn", NULL
22545 };
22546
22547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22548 ecode1 = SWIG_AsVal_double(obj0, &val1);
22549 if (!SWIG_IsOK(ecode1)) {
22550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22551 }
22552 arg1 = static_cast< double >(val1);
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 result = (wxDateTime *)new wxDateTime(arg1);
22556 wxPyEndAllowThreads(__tstate);
22557 if (PyErr_Occurred()) SWIG_fail;
22558 }
22559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22567 PyObject *resultobj = 0;
22568 int arg1 ;
22569 int arg2 = (int) 0 ;
22570 int arg3 = (int) 0 ;
22571 int arg4 = (int) 0 ;
22572 wxDateTime *result = 0 ;
22573 int val1 ;
22574 int ecode1 = 0 ;
22575 int val2 ;
22576 int ecode2 = 0 ;
22577 int val3 ;
22578 int ecode3 = 0 ;
22579 int val4 ;
22580 int ecode4 = 0 ;
22581 PyObject * obj0 = 0 ;
22582 PyObject * obj1 = 0 ;
22583 PyObject * obj2 = 0 ;
22584 PyObject * obj3 = 0 ;
22585 char * kwnames[] = {
22586 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22587 };
22588
22589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22590 ecode1 = SWIG_AsVal_int(obj0, &val1);
22591 if (!SWIG_IsOK(ecode1)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22593 }
22594 arg1 = static_cast< int >(val1);
22595 if (obj1) {
22596 ecode2 = SWIG_AsVal_int(obj1, &val2);
22597 if (!SWIG_IsOK(ecode2)) {
22598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22599 }
22600 arg2 = static_cast< int >(val2);
22601 }
22602 if (obj2) {
22603 ecode3 = SWIG_AsVal_int(obj2, &val3);
22604 if (!SWIG_IsOK(ecode3)) {
22605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22606 }
22607 arg3 = static_cast< int >(val3);
22608 }
22609 if (obj3) {
22610 ecode4 = SWIG_AsVal_int(obj3, &val4);
22611 if (!SWIG_IsOK(ecode4)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22613 }
22614 arg4 = static_cast< int >(val4);
22615 }
22616 {
22617 PyThreadState* __tstate = wxPyBeginAllowThreads();
22618 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22619 wxPyEndAllowThreads(__tstate);
22620 if (PyErr_Occurred()) SWIG_fail;
22621 }
22622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22630 PyObject *resultobj = 0;
22631 int arg1 ;
22632 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22633 int arg3 = (int) wxDateTime::Inv_Year ;
22634 int arg4 = (int) 0 ;
22635 int arg5 = (int) 0 ;
22636 int arg6 = (int) 0 ;
22637 int arg7 = (int) 0 ;
22638 wxDateTime *result = 0 ;
22639 int val1 ;
22640 int ecode1 = 0 ;
22641 int val2 ;
22642 int ecode2 = 0 ;
22643 int val3 ;
22644 int ecode3 = 0 ;
22645 int val4 ;
22646 int ecode4 = 0 ;
22647 int val5 ;
22648 int ecode5 = 0 ;
22649 int val6 ;
22650 int ecode6 = 0 ;
22651 int val7 ;
22652 int ecode7 = 0 ;
22653 PyObject * obj0 = 0 ;
22654 PyObject * obj1 = 0 ;
22655 PyObject * obj2 = 0 ;
22656 PyObject * obj3 = 0 ;
22657 PyObject * obj4 = 0 ;
22658 PyObject * obj5 = 0 ;
22659 PyObject * obj6 = 0 ;
22660 char * kwnames[] = {
22661 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22662 };
22663
22664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22665 ecode1 = SWIG_AsVal_int(obj0, &val1);
22666 if (!SWIG_IsOK(ecode1)) {
22667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22668 }
22669 arg1 = static_cast< int >(val1);
22670 if (obj1) {
22671 ecode2 = SWIG_AsVal_int(obj1, &val2);
22672 if (!SWIG_IsOK(ecode2)) {
22673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22674 }
22675 arg2 = static_cast< wxDateTime::Month >(val2);
22676 }
22677 if (obj2) {
22678 ecode3 = SWIG_AsVal_int(obj2, &val3);
22679 if (!SWIG_IsOK(ecode3)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22681 }
22682 arg3 = static_cast< int >(val3);
22683 }
22684 if (obj3) {
22685 ecode4 = SWIG_AsVal_int(obj3, &val4);
22686 if (!SWIG_IsOK(ecode4)) {
22687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22688 }
22689 arg4 = static_cast< int >(val4);
22690 }
22691 if (obj4) {
22692 ecode5 = SWIG_AsVal_int(obj4, &val5);
22693 if (!SWIG_IsOK(ecode5)) {
22694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22695 }
22696 arg5 = static_cast< int >(val5);
22697 }
22698 if (obj5) {
22699 ecode6 = SWIG_AsVal_int(obj5, &val6);
22700 if (!SWIG_IsOK(ecode6)) {
22701 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22702 }
22703 arg6 = static_cast< int >(val6);
22704 }
22705 if (obj6) {
22706 ecode7 = SWIG_AsVal_int(obj6, &val7);
22707 if (!SWIG_IsOK(ecode7)) {
22708 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22709 }
22710 arg7 = static_cast< int >(val7);
22711 }
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj = 0;
22727 wxDateTime *arg1 = 0 ;
22728 wxDateTime *result = 0 ;
22729 void *argp1 = 0 ;
22730 int res1 = 0 ;
22731 PyObject * obj0 = 0 ;
22732 char * kwnames[] = {
22733 (char *) "date", NULL
22734 };
22735
22736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22737 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22738 if (!SWIG_IsOK(res1)) {
22739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22740 }
22741 if (!argp1) {
22742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22743 }
22744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22759 PyObject *resultobj = 0;
22760 wxDateTime *arg1 = (wxDateTime *) 0 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 PyObject *swig_obj[1] ;
22764
22765 if (!args) SWIG_fail;
22766 swig_obj[0] = args;
22767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22768 if (!SWIG_IsOK(res1)) {
22769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22770 }
22771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22772 {
22773 PyThreadState* __tstate = wxPyBeginAllowThreads();
22774 delete arg1;
22775
22776 wxPyEndAllowThreads(__tstate);
22777 if (PyErr_Occurred()) SWIG_fail;
22778 }
22779 resultobj = SWIG_Py_Void();
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22787 PyObject *resultobj = 0;
22788 wxDateTime *arg1 = (wxDateTime *) 0 ;
22789 wxDateTime *result = 0 ;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 PyObject *swig_obj[1] ;
22793
22794 if (!args) SWIG_fail;
22795 swig_obj[0] = args;
22796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22797 if (!SWIG_IsOK(res1)) {
22798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22799 }
22800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22801 {
22802 PyThreadState* __tstate = wxPyBeginAllowThreads();
22803 {
22804 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22805 result = (wxDateTime *) &_result_ref;
22806 }
22807 wxPyEndAllowThreads(__tstate);
22808 if (PyErr_Occurred()) SWIG_fail;
22809 }
22810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22811 return resultobj;
22812 fail:
22813 return NULL;
22814 }
22815
22816
22817 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22818 PyObject *resultobj = 0;
22819 wxDateTime *arg1 = (wxDateTime *) 0 ;
22820 time_t arg2 ;
22821 wxDateTime *result = 0 ;
22822 void *argp1 = 0 ;
22823 int res1 = 0 ;
22824 unsigned int val2 ;
22825 int ecode2 = 0 ;
22826 PyObject * obj0 = 0 ;
22827 PyObject * obj1 = 0 ;
22828 char * kwnames[] = {
22829 (char *) "self",(char *) "timet", NULL
22830 };
22831
22832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22834 if (!SWIG_IsOK(res1)) {
22835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22836 }
22837 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22838 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22839 if (!SWIG_IsOK(ecode2)) {
22840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22841 }
22842 arg2 = static_cast< time_t >(val2);
22843 {
22844 PyThreadState* __tstate = wxPyBeginAllowThreads();
22845 {
22846 wxDateTime &_result_ref = (arg1)->Set(arg2);
22847 result = (wxDateTime *) &_result_ref;
22848 }
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22860 PyObject *resultobj = 0;
22861 wxDateTime *arg1 = (wxDateTime *) 0 ;
22862 double arg2 ;
22863 wxDateTime *result = 0 ;
22864 void *argp1 = 0 ;
22865 int res1 = 0 ;
22866 double val2 ;
22867 int ecode2 = 0 ;
22868 PyObject * obj0 = 0 ;
22869 PyObject * obj1 = 0 ;
22870 char * kwnames[] = {
22871 (char *) "self",(char *) "jdn", NULL
22872 };
22873
22874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22876 if (!SWIG_IsOK(res1)) {
22877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22878 }
22879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22880 ecode2 = SWIG_AsVal_double(obj1, &val2);
22881 if (!SWIG_IsOK(ecode2)) {
22882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22883 }
22884 arg2 = static_cast< double >(val2);
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 {
22888 wxDateTime &_result_ref = (arg1)->Set(arg2);
22889 result = (wxDateTime *) &_result_ref;
22890 }
22891 wxPyEndAllowThreads(__tstate);
22892 if (PyErr_Occurred()) SWIG_fail;
22893 }
22894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22902 PyObject *resultobj = 0;
22903 wxDateTime *arg1 = (wxDateTime *) 0 ;
22904 int arg2 ;
22905 int arg3 = (int) 0 ;
22906 int arg4 = (int) 0 ;
22907 int arg5 = (int) 0 ;
22908 wxDateTime *result = 0 ;
22909 void *argp1 = 0 ;
22910 int res1 = 0 ;
22911 int val2 ;
22912 int ecode2 = 0 ;
22913 int val3 ;
22914 int ecode3 = 0 ;
22915 int val4 ;
22916 int ecode4 = 0 ;
22917 int val5 ;
22918 int ecode5 = 0 ;
22919 PyObject * obj0 = 0 ;
22920 PyObject * obj1 = 0 ;
22921 PyObject * obj2 = 0 ;
22922 PyObject * obj3 = 0 ;
22923 PyObject * obj4 = 0 ;
22924 char * kwnames[] = {
22925 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22926 };
22927
22928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22930 if (!SWIG_IsOK(res1)) {
22931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22932 }
22933 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22934 ecode2 = SWIG_AsVal_int(obj1, &val2);
22935 if (!SWIG_IsOK(ecode2)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22937 }
22938 arg2 = static_cast< int >(val2);
22939 if (obj2) {
22940 ecode3 = SWIG_AsVal_int(obj2, &val3);
22941 if (!SWIG_IsOK(ecode3)) {
22942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22943 }
22944 arg3 = static_cast< int >(val3);
22945 }
22946 if (obj3) {
22947 ecode4 = SWIG_AsVal_int(obj3, &val4);
22948 if (!SWIG_IsOK(ecode4)) {
22949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22950 }
22951 arg4 = static_cast< int >(val4);
22952 }
22953 if (obj4) {
22954 ecode5 = SWIG_AsVal_int(obj4, &val5);
22955 if (!SWIG_IsOK(ecode5)) {
22956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22957 }
22958 arg5 = static_cast< int >(val5);
22959 }
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 {
22963 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22964 result = (wxDateTime *) &_result_ref;
22965 }
22966 wxPyEndAllowThreads(__tstate);
22967 if (PyErr_Occurred()) SWIG_fail;
22968 }
22969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj = 0;
22978 wxDateTime *arg1 = (wxDateTime *) 0 ;
22979 int arg2 ;
22980 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22981 int arg4 = (int) wxDateTime::Inv_Year ;
22982 int arg5 = (int) 0 ;
22983 int arg6 = (int) 0 ;
22984 int arg7 = (int) 0 ;
22985 int arg8 = (int) 0 ;
22986 wxDateTime *result = 0 ;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 int val2 ;
22990 int ecode2 = 0 ;
22991 int val3 ;
22992 int ecode3 = 0 ;
22993 int val4 ;
22994 int ecode4 = 0 ;
22995 int val5 ;
22996 int ecode5 = 0 ;
22997 int val6 ;
22998 int ecode6 = 0 ;
22999 int val7 ;
23000 int ecode7 = 0 ;
23001 int val8 ;
23002 int ecode8 = 0 ;
23003 PyObject * obj0 = 0 ;
23004 PyObject * obj1 = 0 ;
23005 PyObject * obj2 = 0 ;
23006 PyObject * obj3 = 0 ;
23007 PyObject * obj4 = 0 ;
23008 PyObject * obj5 = 0 ;
23009 PyObject * obj6 = 0 ;
23010 PyObject * obj7 = 0 ;
23011 char * kwnames[] = {
23012 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23013 };
23014
23015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23019 }
23020 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23021 ecode2 = SWIG_AsVal_int(obj1, &val2);
23022 if (!SWIG_IsOK(ecode2)) {
23023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23024 }
23025 arg2 = static_cast< int >(val2);
23026 if (obj2) {
23027 ecode3 = SWIG_AsVal_int(obj2, &val3);
23028 if (!SWIG_IsOK(ecode3)) {
23029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23030 }
23031 arg3 = static_cast< wxDateTime::Month >(val3);
23032 }
23033 if (obj3) {
23034 ecode4 = SWIG_AsVal_int(obj3, &val4);
23035 if (!SWIG_IsOK(ecode4)) {
23036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23037 }
23038 arg4 = static_cast< int >(val4);
23039 }
23040 if (obj4) {
23041 ecode5 = SWIG_AsVal_int(obj4, &val5);
23042 if (!SWIG_IsOK(ecode5)) {
23043 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23044 }
23045 arg5 = static_cast< int >(val5);
23046 }
23047 if (obj5) {
23048 ecode6 = SWIG_AsVal_int(obj5, &val6);
23049 if (!SWIG_IsOK(ecode6)) {
23050 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23051 }
23052 arg6 = static_cast< int >(val6);
23053 }
23054 if (obj6) {
23055 ecode7 = SWIG_AsVal_int(obj6, &val7);
23056 if (!SWIG_IsOK(ecode7)) {
23057 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23058 }
23059 arg7 = static_cast< int >(val7);
23060 }
23061 if (obj7) {
23062 ecode8 = SWIG_AsVal_int(obj7, &val8);
23063 if (!SWIG_IsOK(ecode8)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23065 }
23066 arg8 = static_cast< int >(val8);
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 {
23071 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23072 result = (wxDateTime *) &_result_ref;
23073 }
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23078 return resultobj;
23079 fail:
23080 return NULL;
23081 }
23082
23083
23084 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23085 PyObject *resultobj = 0;
23086 wxDateTime *arg1 = (wxDateTime *) 0 ;
23087 wxDateTime *result = 0 ;
23088 void *argp1 = 0 ;
23089 int res1 = 0 ;
23090 PyObject *swig_obj[1] ;
23091
23092 if (!args) SWIG_fail;
23093 swig_obj[0] = args;
23094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23095 if (!SWIG_IsOK(res1)) {
23096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23097 }
23098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23099 {
23100 PyThreadState* __tstate = wxPyBeginAllowThreads();
23101 {
23102 wxDateTime &_result_ref = (arg1)->ResetTime();
23103 result = (wxDateTime *) &_result_ref;
23104 }
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23109 return resultobj;
23110 fail:
23111 return NULL;
23112 }
23113
23114
23115 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23116 PyObject *resultobj = 0;
23117 wxDateTime *arg1 = (wxDateTime *) 0 ;
23118 int arg2 ;
23119 wxDateTime *result = 0 ;
23120 void *argp1 = 0 ;
23121 int res1 = 0 ;
23122 int val2 ;
23123 int ecode2 = 0 ;
23124 PyObject * obj0 = 0 ;
23125 PyObject * obj1 = 0 ;
23126 char * kwnames[] = {
23127 (char *) "self",(char *) "year", NULL
23128 };
23129
23130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23134 }
23135 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23136 ecode2 = SWIG_AsVal_int(obj1, &val2);
23137 if (!SWIG_IsOK(ecode2)) {
23138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23139 }
23140 arg2 = static_cast< int >(val2);
23141 {
23142 PyThreadState* __tstate = wxPyBeginAllowThreads();
23143 {
23144 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23145 result = (wxDateTime *) &_result_ref;
23146 }
23147 wxPyEndAllowThreads(__tstate);
23148 if (PyErr_Occurred()) SWIG_fail;
23149 }
23150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23158 PyObject *resultobj = 0;
23159 wxDateTime *arg1 = (wxDateTime *) 0 ;
23160 wxDateTime::Month arg2 ;
23161 wxDateTime *result = 0 ;
23162 void *argp1 = 0 ;
23163 int res1 = 0 ;
23164 int val2 ;
23165 int ecode2 = 0 ;
23166 PyObject * obj0 = 0 ;
23167 PyObject * obj1 = 0 ;
23168 char * kwnames[] = {
23169 (char *) "self",(char *) "month", NULL
23170 };
23171
23172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23174 if (!SWIG_IsOK(res1)) {
23175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23176 }
23177 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23178 ecode2 = SWIG_AsVal_int(obj1, &val2);
23179 if (!SWIG_IsOK(ecode2)) {
23180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23181 }
23182 arg2 = static_cast< wxDateTime::Month >(val2);
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 {
23186 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23187 result = (wxDateTime *) &_result_ref;
23188 }
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23200 PyObject *resultobj = 0;
23201 wxDateTime *arg1 = (wxDateTime *) 0 ;
23202 int arg2 ;
23203 wxDateTime *result = 0 ;
23204 void *argp1 = 0 ;
23205 int res1 = 0 ;
23206 int val2 ;
23207 int ecode2 = 0 ;
23208 PyObject * obj0 = 0 ;
23209 PyObject * obj1 = 0 ;
23210 char * kwnames[] = {
23211 (char *) "self",(char *) "day", NULL
23212 };
23213
23214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23216 if (!SWIG_IsOK(res1)) {
23217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23218 }
23219 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23220 ecode2 = SWIG_AsVal_int(obj1, &val2);
23221 if (!SWIG_IsOK(ecode2)) {
23222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23223 }
23224 arg2 = static_cast< int >(val2);
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 {
23228 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23229 result = (wxDateTime *) &_result_ref;
23230 }
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxDateTime *arg1 = (wxDateTime *) 0 ;
23244 int arg2 ;
23245 wxDateTime *result = 0 ;
23246 void *argp1 = 0 ;
23247 int res1 = 0 ;
23248 int val2 ;
23249 int ecode2 = 0 ;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 char * kwnames[] = {
23253 (char *) "self",(char *) "hour", NULL
23254 };
23255
23256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23260 }
23261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23262 ecode2 = SWIG_AsVal_int(obj1, &val2);
23263 if (!SWIG_IsOK(ecode2)) {
23264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23265 }
23266 arg2 = static_cast< int >(val2);
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 {
23270 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23271 result = (wxDateTime *) &_result_ref;
23272 }
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj = 0;
23285 wxDateTime *arg1 = (wxDateTime *) 0 ;
23286 int arg2 ;
23287 wxDateTime *result = 0 ;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 int val2 ;
23291 int ecode2 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "self",(char *) "minute", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23300 if (!SWIG_IsOK(res1)) {
23301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23302 }
23303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23304 ecode2 = SWIG_AsVal_int(obj1, &val2);
23305 if (!SWIG_IsOK(ecode2)) {
23306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23307 }
23308 arg2 = static_cast< int >(val2);
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 {
23312 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23313 result = (wxDateTime *) &_result_ref;
23314 }
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj = 0;
23327 wxDateTime *arg1 = (wxDateTime *) 0 ;
23328 int arg2 ;
23329 wxDateTime *result = 0 ;
23330 void *argp1 = 0 ;
23331 int res1 = 0 ;
23332 int val2 ;
23333 int ecode2 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 PyObject * obj1 = 0 ;
23336 char * kwnames[] = {
23337 (char *) "self",(char *) "second", NULL
23338 };
23339
23340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23344 }
23345 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23346 ecode2 = SWIG_AsVal_int(obj1, &val2);
23347 if (!SWIG_IsOK(ecode2)) {
23348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23349 }
23350 arg2 = static_cast< int >(val2);
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 {
23354 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23355 result = (wxDateTime *) &_result_ref;
23356 }
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj = 0;
23369 wxDateTime *arg1 = (wxDateTime *) 0 ;
23370 int arg2 ;
23371 wxDateTime *result = 0 ;
23372 void *argp1 = 0 ;
23373 int res1 = 0 ;
23374 int val2 ;
23375 int ecode2 = 0 ;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char * kwnames[] = {
23379 (char *) "self",(char *) "millisecond", NULL
23380 };
23381
23382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23384 if (!SWIG_IsOK(res1)) {
23385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23386 }
23387 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23388 ecode2 = SWIG_AsVal_int(obj1, &val2);
23389 if (!SWIG_IsOK(ecode2)) {
23390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23391 }
23392 arg2 = static_cast< int >(val2);
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 {
23396 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23397 result = (wxDateTime *) &_result_ref;
23398 }
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23410 PyObject *resultobj = 0;
23411 wxDateTime *arg1 = (wxDateTime *) 0 ;
23412 wxDateTime::WeekDay arg2 ;
23413 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23414 wxDateTime *result = 0 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 int val2 ;
23418 int ecode2 = 0 ;
23419 int val3 ;
23420 int ecode3 = 0 ;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 PyObject * obj2 = 0 ;
23424 char * kwnames[] = {
23425 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23426 };
23427
23428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23430 if (!SWIG_IsOK(res1)) {
23431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23432 }
23433 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23434 ecode2 = SWIG_AsVal_int(obj1, &val2);
23435 if (!SWIG_IsOK(ecode2)) {
23436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23437 }
23438 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23439 if (obj2) {
23440 ecode3 = SWIG_AsVal_int(obj2, &val3);
23441 if (!SWIG_IsOK(ecode3)) {
23442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23443 }
23444 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 {
23449 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23450 result = (wxDateTime *) &_result_ref;
23451 }
23452 wxPyEndAllowThreads(__tstate);
23453 if (PyErr_Occurred()) SWIG_fail;
23454 }
23455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23456 return resultobj;
23457 fail:
23458 return NULL;
23459 }
23460
23461
23462 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 wxDateTime *arg1 = (wxDateTime *) 0 ;
23465 wxDateTime::WeekDay arg2 ;
23466 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23467 wxDateTime result;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 int val2 ;
23471 int ecode2 = 0 ;
23472 int val3 ;
23473 int ecode3 = 0 ;
23474 PyObject * obj0 = 0 ;
23475 PyObject * obj1 = 0 ;
23476 PyObject * obj2 = 0 ;
23477 char * kwnames[] = {
23478 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23479 };
23480
23481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23483 if (!SWIG_IsOK(res1)) {
23484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23485 }
23486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23487 ecode2 = SWIG_AsVal_int(obj1, &val2);
23488 if (!SWIG_IsOK(ecode2)) {
23489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23490 }
23491 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23492 if (obj2) {
23493 ecode3 = SWIG_AsVal_int(obj2, &val3);
23494 if (!SWIG_IsOK(ecode3)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23496 }
23497 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj = 0;
23514 wxDateTime *arg1 = (wxDateTime *) 0 ;
23515 wxDateTime::WeekDay arg2 ;
23516 wxDateTime *result = 0 ;
23517 void *argp1 = 0 ;
23518 int res1 = 0 ;
23519 int val2 ;
23520 int ecode2 = 0 ;
23521 PyObject * obj0 = 0 ;
23522 PyObject * obj1 = 0 ;
23523 char * kwnames[] = {
23524 (char *) "self",(char *) "weekday", NULL
23525 };
23526
23527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23529 if (!SWIG_IsOK(res1)) {
23530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23531 }
23532 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23533 ecode2 = SWIG_AsVal_int(obj1, &val2);
23534 if (!SWIG_IsOK(ecode2)) {
23535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23536 }
23537 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 {
23541 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23542 result = (wxDateTime *) &_result_ref;
23543 }
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23555 PyObject *resultobj = 0;
23556 wxDateTime *arg1 = (wxDateTime *) 0 ;
23557 wxDateTime::WeekDay arg2 ;
23558 wxDateTime result;
23559 void *argp1 = 0 ;
23560 int res1 = 0 ;
23561 int val2 ;
23562 int ecode2 = 0 ;
23563 PyObject * obj0 = 0 ;
23564 PyObject * obj1 = 0 ;
23565 char * kwnames[] = {
23566 (char *) "self",(char *) "weekday", NULL
23567 };
23568
23569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23571 if (!SWIG_IsOK(res1)) {
23572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23573 }
23574 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23575 ecode2 = SWIG_AsVal_int(obj1, &val2);
23576 if (!SWIG_IsOK(ecode2)) {
23577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23578 }
23579 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23580 {
23581 PyThreadState* __tstate = wxPyBeginAllowThreads();
23582 result = (arg1)->GetNextWeekDay(arg2);
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23587 return resultobj;
23588 fail:
23589 return NULL;
23590 }
23591
23592
23593 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23594 PyObject *resultobj = 0;
23595 wxDateTime *arg1 = (wxDateTime *) 0 ;
23596 wxDateTime::WeekDay arg2 ;
23597 wxDateTime *result = 0 ;
23598 void *argp1 = 0 ;
23599 int res1 = 0 ;
23600 int val2 ;
23601 int ecode2 = 0 ;
23602 PyObject * obj0 = 0 ;
23603 PyObject * obj1 = 0 ;
23604 char * kwnames[] = {
23605 (char *) "self",(char *) "weekday", NULL
23606 };
23607
23608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23610 if (!SWIG_IsOK(res1)) {
23611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23612 }
23613 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23614 ecode2 = SWIG_AsVal_int(obj1, &val2);
23615 if (!SWIG_IsOK(ecode2)) {
23616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23617 }
23618 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 {
23622 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23623 result = (wxDateTime *) &_result_ref;
23624 }
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23636 PyObject *resultobj = 0;
23637 wxDateTime *arg1 = (wxDateTime *) 0 ;
23638 wxDateTime::WeekDay arg2 ;
23639 wxDateTime result;
23640 void *argp1 = 0 ;
23641 int res1 = 0 ;
23642 int val2 ;
23643 int ecode2 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 PyObject * obj1 = 0 ;
23646 char * kwnames[] = {
23647 (char *) "self",(char *) "weekday", NULL
23648 };
23649
23650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23652 if (!SWIG_IsOK(res1)) {
23653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23654 }
23655 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23656 ecode2 = SWIG_AsVal_int(obj1, &val2);
23657 if (!SWIG_IsOK(ecode2)) {
23658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23659 }
23660 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = (arg1)->GetPrevWeekDay(arg2);
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23675 PyObject *resultobj = 0;
23676 wxDateTime *arg1 = (wxDateTime *) 0 ;
23677 wxDateTime::WeekDay arg2 ;
23678 int arg3 = (int) 1 ;
23679 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23680 int arg5 = (int) wxDateTime::Inv_Year ;
23681 bool result;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 int val2 ;
23685 int ecode2 = 0 ;
23686 int val3 ;
23687 int ecode3 = 0 ;
23688 int val4 ;
23689 int ecode4 = 0 ;
23690 int val5 ;
23691 int ecode5 = 0 ;
23692 PyObject * obj0 = 0 ;
23693 PyObject * obj1 = 0 ;
23694 PyObject * obj2 = 0 ;
23695 PyObject * obj3 = 0 ;
23696 PyObject * obj4 = 0 ;
23697 char * kwnames[] = {
23698 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23699 };
23700
23701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23705 }
23706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23707 ecode2 = SWIG_AsVal_int(obj1, &val2);
23708 if (!SWIG_IsOK(ecode2)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23710 }
23711 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23712 if (obj2) {
23713 ecode3 = SWIG_AsVal_int(obj2, &val3);
23714 if (!SWIG_IsOK(ecode3)) {
23715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23716 }
23717 arg3 = static_cast< int >(val3);
23718 }
23719 if (obj3) {
23720 ecode4 = SWIG_AsVal_int(obj3, &val4);
23721 if (!SWIG_IsOK(ecode4)) {
23722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23723 }
23724 arg4 = static_cast< wxDateTime::Month >(val4);
23725 }
23726 if (obj4) {
23727 ecode5 = SWIG_AsVal_int(obj4, &val5);
23728 if (!SWIG_IsOK(ecode5)) {
23729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23730 }
23731 arg5 = static_cast< int >(val5);
23732 }
23733 {
23734 PyThreadState* __tstate = wxPyBeginAllowThreads();
23735 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23736 wxPyEndAllowThreads(__tstate);
23737 if (PyErr_Occurred()) SWIG_fail;
23738 }
23739 {
23740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23741 }
23742 return resultobj;
23743 fail:
23744 return NULL;
23745 }
23746
23747
23748 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23749 PyObject *resultobj = 0;
23750 wxDateTime *arg1 = (wxDateTime *) 0 ;
23751 wxDateTime::WeekDay arg2 ;
23752 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23753 int arg4 = (int) wxDateTime::Inv_Year ;
23754 bool result;
23755 void *argp1 = 0 ;
23756 int res1 = 0 ;
23757 int val2 ;
23758 int ecode2 = 0 ;
23759 int val3 ;
23760 int ecode3 = 0 ;
23761 int val4 ;
23762 int ecode4 = 0 ;
23763 PyObject * obj0 = 0 ;
23764 PyObject * obj1 = 0 ;
23765 PyObject * obj2 = 0 ;
23766 PyObject * obj3 = 0 ;
23767 char * kwnames[] = {
23768 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23769 };
23770
23771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23773 if (!SWIG_IsOK(res1)) {
23774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23775 }
23776 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23777 ecode2 = SWIG_AsVal_int(obj1, &val2);
23778 if (!SWIG_IsOK(ecode2)) {
23779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23780 }
23781 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23782 if (obj2) {
23783 ecode3 = SWIG_AsVal_int(obj2, &val3);
23784 if (!SWIG_IsOK(ecode3)) {
23785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23786 }
23787 arg3 = static_cast< wxDateTime::Month >(val3);
23788 }
23789 if (obj3) {
23790 ecode4 = SWIG_AsVal_int(obj3, &val4);
23791 if (!SWIG_IsOK(ecode4)) {
23792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23793 }
23794 arg4 = static_cast< int >(val4);
23795 }
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 {
23803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23804 }
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj = 0;
23813 wxDateTime *arg1 = (wxDateTime *) 0 ;
23814 wxDateTime::WeekDay arg2 ;
23815 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23816 int arg4 = (int) wxDateTime::Inv_Year ;
23817 wxDateTime result;
23818 void *argp1 = 0 ;
23819 int res1 = 0 ;
23820 int val2 ;
23821 int ecode2 = 0 ;
23822 int val3 ;
23823 int ecode3 = 0 ;
23824 int val4 ;
23825 int ecode4 = 0 ;
23826 PyObject * obj0 = 0 ;
23827 PyObject * obj1 = 0 ;
23828 PyObject * obj2 = 0 ;
23829 PyObject * obj3 = 0 ;
23830 char * kwnames[] = {
23831 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23832 };
23833
23834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23836 if (!SWIG_IsOK(res1)) {
23837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23838 }
23839 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23840 ecode2 = SWIG_AsVal_int(obj1, &val2);
23841 if (!SWIG_IsOK(ecode2)) {
23842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23843 }
23844 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23845 if (obj2) {
23846 ecode3 = SWIG_AsVal_int(obj2, &val3);
23847 if (!SWIG_IsOK(ecode3)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23849 }
23850 arg3 = static_cast< wxDateTime::Month >(val3);
23851 }
23852 if (obj3) {
23853 ecode4 = SWIG_AsVal_int(obj3, &val4);
23854 if (!SWIG_IsOK(ecode4)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23856 }
23857 arg4 = static_cast< int >(val4);
23858 }
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23866 return resultobj;
23867 fail:
23868 return NULL;
23869 }
23870
23871
23872 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23873 PyObject *resultobj = 0;
23874 wxDateTime *arg1 = (wxDateTime *) 0 ;
23875 int arg2 ;
23876 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23877 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23878 bool result;
23879 void *argp1 = 0 ;
23880 int res1 = 0 ;
23881 int val2 ;
23882 int ecode2 = 0 ;
23883 int val3 ;
23884 int ecode3 = 0 ;
23885 int val4 ;
23886 int ecode4 = 0 ;
23887 PyObject * obj0 = 0 ;
23888 PyObject * obj1 = 0 ;
23889 PyObject * obj2 = 0 ;
23890 PyObject * obj3 = 0 ;
23891 char * kwnames[] = {
23892 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23893 };
23894
23895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23897 if (!SWIG_IsOK(res1)) {
23898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23899 }
23900 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23901 ecode2 = SWIG_AsVal_int(obj1, &val2);
23902 if (!SWIG_IsOK(ecode2)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23904 }
23905 arg2 = static_cast< int >(val2);
23906 if (obj2) {
23907 ecode3 = SWIG_AsVal_int(obj2, &val3);
23908 if (!SWIG_IsOK(ecode3)) {
23909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23910 }
23911 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23912 }
23913 if (obj3) {
23914 ecode4 = SWIG_AsVal_int(obj3, &val4);
23915 if (!SWIG_IsOK(ecode4)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23917 }
23918 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23919 }
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 {
23927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23928 }
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj = 0;
23937 wxDateTime *arg1 = (wxDateTime *) 0 ;
23938 int arg2 ;
23939 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23940 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23941 wxDateTime result;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 int val2 ;
23945 int ecode2 = 0 ;
23946 int val3 ;
23947 int ecode3 = 0 ;
23948 int val4 ;
23949 int ecode4 = 0 ;
23950 PyObject * obj0 = 0 ;
23951 PyObject * obj1 = 0 ;
23952 PyObject * obj2 = 0 ;
23953 PyObject * obj3 = 0 ;
23954 char * kwnames[] = {
23955 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23956 };
23957
23958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23960 if (!SWIG_IsOK(res1)) {
23961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23962 }
23963 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23964 ecode2 = SWIG_AsVal_int(obj1, &val2);
23965 if (!SWIG_IsOK(ecode2)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23967 }
23968 arg2 = static_cast< int >(val2);
23969 if (obj2) {
23970 ecode3 = SWIG_AsVal_int(obj2, &val3);
23971 if (!SWIG_IsOK(ecode3)) {
23972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23973 }
23974 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23975 }
23976 if (obj3) {
23977 ecode4 = SWIG_AsVal_int(obj3, &val4);
23978 if (!SWIG_IsOK(ecode4)) {
23979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23980 }
23981 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23982 }
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 result = (arg1)->GetWeek(arg2,arg3,arg4);
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23990 return resultobj;
23991 fail:
23992 return NULL;
23993 }
23994
23995
23996 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23997 PyObject *resultobj = 0;
23998 int arg1 ;
23999 int arg2 ;
24000 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24001 wxDateTime result;
24002 int val1 ;
24003 int ecode1 = 0 ;
24004 int val2 ;
24005 int ecode2 = 0 ;
24006 int val3 ;
24007 int ecode3 = 0 ;
24008 PyObject * obj0 = 0 ;
24009 PyObject * obj1 = 0 ;
24010 PyObject * obj2 = 0 ;
24011 char * kwnames[] = {
24012 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24013 };
24014
24015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24016 ecode1 = SWIG_AsVal_int(obj0, &val1);
24017 if (!SWIG_IsOK(ecode1)) {
24018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24019 }
24020 arg1 = static_cast< int >(val1);
24021 ecode2 = SWIG_AsVal_int(obj1, &val2);
24022 if (!SWIG_IsOK(ecode2)) {
24023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24024 }
24025 arg2 = static_cast< int >(val2);
24026 if (obj2) {
24027 ecode3 = SWIG_AsVal_int(obj2, &val3);
24028 if (!SWIG_IsOK(ecode3)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24030 }
24031 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24032 }
24033 {
24034 PyThreadState* __tstate = wxPyBeginAllowThreads();
24035 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj = 0;
24048 wxDateTime *arg1 = (wxDateTime *) 0 ;
24049 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24050 int arg3 = (int) wxDateTime::Inv_Year ;
24051 wxDateTime *result = 0 ;
24052 void *argp1 = 0 ;
24053 int res1 = 0 ;
24054 int val2 ;
24055 int ecode2 = 0 ;
24056 int val3 ;
24057 int ecode3 = 0 ;
24058 PyObject * obj0 = 0 ;
24059 PyObject * obj1 = 0 ;
24060 PyObject * obj2 = 0 ;
24061 char * kwnames[] = {
24062 (char *) "self",(char *) "month",(char *) "year", NULL
24063 };
24064
24065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24067 if (!SWIG_IsOK(res1)) {
24068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24069 }
24070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24071 if (obj1) {
24072 ecode2 = SWIG_AsVal_int(obj1, &val2);
24073 if (!SWIG_IsOK(ecode2)) {
24074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24075 }
24076 arg2 = static_cast< wxDateTime::Month >(val2);
24077 }
24078 if (obj2) {
24079 ecode3 = SWIG_AsVal_int(obj2, &val3);
24080 if (!SWIG_IsOK(ecode3)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24082 }
24083 arg3 = static_cast< int >(val3);
24084 }
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 {
24088 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24089 result = (wxDateTime *) &_result_ref;
24090 }
24091 wxPyEndAllowThreads(__tstate);
24092 if (PyErr_Occurred()) SWIG_fail;
24093 }
24094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24095 return resultobj;
24096 fail:
24097 return NULL;
24098 }
24099
24100
24101 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24102 PyObject *resultobj = 0;
24103 wxDateTime *arg1 = (wxDateTime *) 0 ;
24104 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24105 int arg3 = (int) wxDateTime::Inv_Year ;
24106 wxDateTime result;
24107 void *argp1 = 0 ;
24108 int res1 = 0 ;
24109 int val2 ;
24110 int ecode2 = 0 ;
24111 int val3 ;
24112 int ecode3 = 0 ;
24113 PyObject * obj0 = 0 ;
24114 PyObject * obj1 = 0 ;
24115 PyObject * obj2 = 0 ;
24116 char * kwnames[] = {
24117 (char *) "self",(char *) "month",(char *) "year", NULL
24118 };
24119
24120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24122 if (!SWIG_IsOK(res1)) {
24123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24124 }
24125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24126 if (obj1) {
24127 ecode2 = SWIG_AsVal_int(obj1, &val2);
24128 if (!SWIG_IsOK(ecode2)) {
24129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24130 }
24131 arg2 = static_cast< wxDateTime::Month >(val2);
24132 }
24133 if (obj2) {
24134 ecode3 = SWIG_AsVal_int(obj2, &val3);
24135 if (!SWIG_IsOK(ecode3)) {
24136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24137 }
24138 arg3 = static_cast< int >(val3);
24139 }
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 result = (arg1)->GetLastMonthDay(arg2,arg3);
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj = 0;
24155 wxDateTime *arg1 = (wxDateTime *) 0 ;
24156 int arg2 ;
24157 wxDateTime *result = 0 ;
24158 void *argp1 = 0 ;
24159 int res1 = 0 ;
24160 int val2 ;
24161 int ecode2 = 0 ;
24162 PyObject * obj0 = 0 ;
24163 PyObject * obj1 = 0 ;
24164 char * kwnames[] = {
24165 (char *) "self",(char *) "yday", NULL
24166 };
24167
24168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24172 }
24173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24174 ecode2 = SWIG_AsVal_int(obj1, &val2);
24175 if (!SWIG_IsOK(ecode2)) {
24176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24177 }
24178 arg2 = static_cast< int >(val2);
24179 {
24180 PyThreadState* __tstate = wxPyBeginAllowThreads();
24181 {
24182 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24183 result = (wxDateTime *) &_result_ref;
24184 }
24185 wxPyEndAllowThreads(__tstate);
24186 if (PyErr_Occurred()) SWIG_fail;
24187 }
24188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24189 return resultobj;
24190 fail:
24191 return NULL;
24192 }
24193
24194
24195 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24196 PyObject *resultobj = 0;
24197 wxDateTime *arg1 = (wxDateTime *) 0 ;
24198 int arg2 ;
24199 wxDateTime result;
24200 void *argp1 = 0 ;
24201 int res1 = 0 ;
24202 int val2 ;
24203 int ecode2 = 0 ;
24204 PyObject * obj0 = 0 ;
24205 PyObject * obj1 = 0 ;
24206 char * kwnames[] = {
24207 (char *) "self",(char *) "yday", NULL
24208 };
24209
24210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24212 if (!SWIG_IsOK(res1)) {
24213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24214 }
24215 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24216 ecode2 = SWIG_AsVal_int(obj1, &val2);
24217 if (!SWIG_IsOK(ecode2)) {
24218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24219 }
24220 arg2 = static_cast< int >(val2);
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 result = (arg1)->GetYearDay(arg2);
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24235 PyObject *resultobj = 0;
24236 wxDateTime *arg1 = (wxDateTime *) 0 ;
24237 double result;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 PyObject *swig_obj[1] ;
24241
24242 if (!args) SWIG_fail;
24243 swig_obj[0] = args;
24244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24247 }
24248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (double)(arg1)->GetJulianDayNumber();
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 resultobj = SWIG_From_double(static_cast< double >(result));
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 PyObject *resultobj = 0;
24264 wxDateTime *arg1 = (wxDateTime *) 0 ;
24265 double result;
24266 void *argp1 = 0 ;
24267 int res1 = 0 ;
24268 PyObject *swig_obj[1] ;
24269
24270 if (!args) SWIG_fail;
24271 swig_obj[0] = args;
24272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24273 if (!SWIG_IsOK(res1)) {
24274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24275 }
24276 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24277 {
24278 PyThreadState* __tstate = wxPyBeginAllowThreads();
24279 result = (double)(arg1)->GetJDN();
24280 wxPyEndAllowThreads(__tstate);
24281 if (PyErr_Occurred()) SWIG_fail;
24282 }
24283 resultobj = SWIG_From_double(static_cast< double >(result));
24284 return resultobj;
24285 fail:
24286 return NULL;
24287 }
24288
24289
24290 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 PyObject *resultobj = 0;
24292 wxDateTime *arg1 = (wxDateTime *) 0 ;
24293 double result;
24294 void *argp1 = 0 ;
24295 int res1 = 0 ;
24296 PyObject *swig_obj[1] ;
24297
24298 if (!args) SWIG_fail;
24299 swig_obj[0] = args;
24300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24301 if (!SWIG_IsOK(res1)) {
24302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24303 }
24304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_From_double(static_cast< double >(result));
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 PyObject *resultobj = 0;
24320 wxDateTime *arg1 = (wxDateTime *) 0 ;
24321 double result;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 PyObject *swig_obj[1] ;
24325
24326 if (!args) SWIG_fail;
24327 swig_obj[0] = args;
24328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24329 if (!SWIG_IsOK(res1)) {
24330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24331 }
24332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24333 {
24334 PyThreadState* __tstate = wxPyBeginAllowThreads();
24335 result = (double)(arg1)->GetMJD();
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 resultobj = SWIG_From_double(static_cast< double >(result));
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24347 PyObject *resultobj = 0;
24348 wxDateTime *arg1 = (wxDateTime *) 0 ;
24349 double result;
24350 void *argp1 = 0 ;
24351 int res1 = 0 ;
24352 PyObject *swig_obj[1] ;
24353
24354 if (!args) SWIG_fail;
24355 swig_obj[0] = args;
24356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24357 if (!SWIG_IsOK(res1)) {
24358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24359 }
24360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 result = (double)(arg1)->GetRataDie();
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_From_double(static_cast< double >(result));
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24375 PyObject *resultobj = 0;
24376 wxDateTime *arg1 = (wxDateTime *) 0 ;
24377 wxDateTime::TimeZone *arg2 = 0 ;
24378 bool arg3 = (bool) false ;
24379 wxDateTime result;
24380 void *argp1 = 0 ;
24381 int res1 = 0 ;
24382 bool temp2 = false ;
24383 bool val3 ;
24384 int ecode3 = 0 ;
24385 PyObject * obj0 = 0 ;
24386 PyObject * obj1 = 0 ;
24387 PyObject * obj2 = 0 ;
24388 char * kwnames[] = {
24389 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24390 };
24391
24392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 if (!SWIG_IsOK(res1)) {
24395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24396 }
24397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24398 {
24399 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24400 temp2 = true;
24401 }
24402 if (obj2) {
24403 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24404 if (!SWIG_IsOK(ecode3)) {
24405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24406 }
24407 arg3 = static_cast< bool >(val3);
24408 }
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24416 {
24417 if (temp2) delete arg2;
24418 }
24419 return resultobj;
24420 fail:
24421 {
24422 if (temp2) delete arg2;
24423 }
24424 return NULL;
24425 }
24426
24427
24428 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24429 PyObject *resultobj = 0;
24430 wxDateTime *arg1 = (wxDateTime *) 0 ;
24431 wxDateTime::TimeZone *arg2 = 0 ;
24432 bool arg3 = (bool) false ;
24433 wxDateTime *result = 0 ;
24434 void *argp1 = 0 ;
24435 int res1 = 0 ;
24436 bool temp2 = false ;
24437 bool val3 ;
24438 int ecode3 = 0 ;
24439 PyObject * obj0 = 0 ;
24440 PyObject * obj1 = 0 ;
24441 PyObject * obj2 = 0 ;
24442 char * kwnames[] = {
24443 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24444 };
24445
24446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24448 if (!SWIG_IsOK(res1)) {
24449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24450 }
24451 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24452 {
24453 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24454 temp2 = true;
24455 }
24456 if (obj2) {
24457 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24458 if (!SWIG_IsOK(ecode3)) {
24459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24460 }
24461 arg3 = static_cast< bool >(val3);
24462 }
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 {
24466 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24467 result = (wxDateTime *) &_result_ref;
24468 }
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24473 {
24474 if (temp2) delete arg2;
24475 }
24476 return resultobj;
24477 fail:
24478 {
24479 if (temp2) delete arg2;
24480 }
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24486 PyObject *resultobj = 0;
24487 wxDateTime *arg1 = (wxDateTime *) 0 ;
24488 wxDateTime::TimeZone *arg2 = 0 ;
24489 bool arg3 = (bool) false ;
24490 wxDateTime result;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 bool temp2 = false ;
24494 bool val3 ;
24495 int ecode3 = 0 ;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 PyObject * obj2 = 0 ;
24499 char * kwnames[] = {
24500 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24501 };
24502
24503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24505 if (!SWIG_IsOK(res1)) {
24506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24507 }
24508 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24509 {
24510 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24511 temp2 = true;
24512 }
24513 if (obj2) {
24514 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24515 if (!SWIG_IsOK(ecode3)) {
24516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24517 }
24518 arg3 = static_cast< bool >(val3);
24519 }
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24523 wxPyEndAllowThreads(__tstate);
24524 if (PyErr_Occurred()) SWIG_fail;
24525 }
24526 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24527 {
24528 if (temp2) delete arg2;
24529 }
24530 return resultobj;
24531 fail:
24532 {
24533 if (temp2) delete arg2;
24534 }
24535 return NULL;
24536 }
24537
24538
24539 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj = 0;
24541 wxDateTime *arg1 = (wxDateTime *) 0 ;
24542 wxDateTime::TimeZone *arg2 = 0 ;
24543 bool arg3 = (bool) false ;
24544 wxDateTime *result = 0 ;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 bool temp2 = false ;
24548 bool val3 ;
24549 int ecode3 = 0 ;
24550 PyObject * obj0 = 0 ;
24551 PyObject * obj1 = 0 ;
24552 PyObject * obj2 = 0 ;
24553 char * kwnames[] = {
24554 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24555 };
24556
24557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24559 if (!SWIG_IsOK(res1)) {
24560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24561 }
24562 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24563 {
24564 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24565 temp2 = true;
24566 }
24567 if (obj2) {
24568 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24569 if (!SWIG_IsOK(ecode3)) {
24570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24571 }
24572 arg3 = static_cast< bool >(val3);
24573 }
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 {
24577 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24578 result = (wxDateTime *) &_result_ref;
24579 }
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24584 {
24585 if (temp2) delete arg2;
24586 }
24587 return resultobj;
24588 fail:
24589 {
24590 if (temp2) delete arg2;
24591 }
24592 return NULL;
24593 }
24594
24595
24596 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24597 PyObject *resultobj = 0;
24598 wxDateTime *arg1 = (wxDateTime *) 0 ;
24599 bool arg2 = (bool) false ;
24600 wxDateTime result;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 bool val2 ;
24604 int ecode2 = 0 ;
24605 PyObject * obj0 = 0 ;
24606 PyObject * obj1 = 0 ;
24607 char * kwnames[] = {
24608 (char *) "self",(char *) "noDST", NULL
24609 };
24610
24611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24613 if (!SWIG_IsOK(res1)) {
24614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24615 }
24616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24617 if (obj1) {
24618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24619 if (!SWIG_IsOK(ecode2)) {
24620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24621 }
24622 arg2 = static_cast< bool >(val2);
24623 }
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj = 0;
24639 wxDateTime *arg1 = (wxDateTime *) 0 ;
24640 bool arg2 = (bool) false ;
24641 wxDateTime *result = 0 ;
24642 void *argp1 = 0 ;
24643 int res1 = 0 ;
24644 bool val2 ;
24645 int ecode2 = 0 ;
24646 PyObject * obj0 = 0 ;
24647 PyObject * obj1 = 0 ;
24648 char * kwnames[] = {
24649 (char *) "self",(char *) "noDST", NULL
24650 };
24651
24652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24654 if (!SWIG_IsOK(res1)) {
24655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24656 }
24657 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24658 if (obj1) {
24659 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24660 if (!SWIG_IsOK(ecode2)) {
24661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24662 }
24663 arg2 = static_cast< bool >(val2);
24664 }
24665 {
24666 PyThreadState* __tstate = wxPyBeginAllowThreads();
24667 {
24668 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24669 result = (wxDateTime *) &_result_ref;
24670 }
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj = 0;
24683 wxDateTime *arg1 = (wxDateTime *) 0 ;
24684 bool arg2 = (bool) false ;
24685 wxDateTime result;
24686 void *argp1 = 0 ;
24687 int res1 = 0 ;
24688 bool val2 ;
24689 int ecode2 = 0 ;
24690 PyObject * obj0 = 0 ;
24691 PyObject * obj1 = 0 ;
24692 char * kwnames[] = {
24693 (char *) "self",(char *) "noDST", NULL
24694 };
24695
24696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24698 if (!SWIG_IsOK(res1)) {
24699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24700 }
24701 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24702 if (obj1) {
24703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24704 if (!SWIG_IsOK(ecode2)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24706 }
24707 arg2 = static_cast< bool >(val2);
24708 }
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24723 PyObject *resultobj = 0;
24724 wxDateTime *arg1 = (wxDateTime *) 0 ;
24725 bool arg2 = (bool) false ;
24726 wxDateTime *result = 0 ;
24727 void *argp1 = 0 ;
24728 int res1 = 0 ;
24729 bool val2 ;
24730 int ecode2 = 0 ;
24731 PyObject * obj0 = 0 ;
24732 PyObject * obj1 = 0 ;
24733 char * kwnames[] = {
24734 (char *) "self",(char *) "noDST", NULL
24735 };
24736
24737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24739 if (!SWIG_IsOK(res1)) {
24740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24741 }
24742 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24743 if (obj1) {
24744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24745 if (!SWIG_IsOK(ecode2)) {
24746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24747 }
24748 arg2 = static_cast< bool >(val2);
24749 }
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 {
24753 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24754 result = (wxDateTime *) &_result_ref;
24755 }
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24760 return resultobj;
24761 fail:
24762 return NULL;
24763 }
24764
24765
24766 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24767 PyObject *resultobj = 0;
24768 wxDateTime *arg1 = (wxDateTime *) 0 ;
24769 bool arg2 = (bool) false ;
24770 wxDateTime result;
24771 void *argp1 = 0 ;
24772 int res1 = 0 ;
24773 bool val2 ;
24774 int ecode2 = 0 ;
24775 PyObject * obj0 = 0 ;
24776 PyObject * obj1 = 0 ;
24777 char * kwnames[] = {
24778 (char *) "self",(char *) "noDST", NULL
24779 };
24780
24781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24783 if (!SWIG_IsOK(res1)) {
24784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24785 }
24786 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24787 if (obj1) {
24788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24789 if (!SWIG_IsOK(ecode2)) {
24790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24791 }
24792 arg2 = static_cast< bool >(val2);
24793 }
24794 {
24795 PyThreadState* __tstate = wxPyBeginAllowThreads();
24796 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24797 wxPyEndAllowThreads(__tstate);
24798 if (PyErr_Occurred()) SWIG_fail;
24799 }
24800 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj = 0;
24809 wxDateTime *arg1 = (wxDateTime *) 0 ;
24810 bool arg2 = (bool) false ;
24811 wxDateTime *result = 0 ;
24812 void *argp1 = 0 ;
24813 int res1 = 0 ;
24814 bool val2 ;
24815 int ecode2 = 0 ;
24816 PyObject * obj0 = 0 ;
24817 PyObject * obj1 = 0 ;
24818 char * kwnames[] = {
24819 (char *) "self",(char *) "noDST", NULL
24820 };
24821
24822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24824 if (!SWIG_IsOK(res1)) {
24825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24826 }
24827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24828 if (obj1) {
24829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24830 if (!SWIG_IsOK(ecode2)) {
24831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24832 }
24833 arg2 = static_cast< bool >(val2);
24834 }
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 {
24838 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24839 result = (wxDateTime *) &_result_ref;
24840 }
24841 wxPyEndAllowThreads(__tstate);
24842 if (PyErr_Occurred()) SWIG_fail;
24843 }
24844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj = 0;
24853 wxDateTime *arg1 = (wxDateTime *) 0 ;
24854 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24855 int result;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 int val2 ;
24859 int ecode2 = 0 ;
24860 PyObject * obj0 = 0 ;
24861 PyObject * obj1 = 0 ;
24862 char * kwnames[] = {
24863 (char *) "self",(char *) "country", NULL
24864 };
24865
24866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24868 if (!SWIG_IsOK(res1)) {
24869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24870 }
24871 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24872 if (obj1) {
24873 ecode2 = SWIG_AsVal_int(obj1, &val2);
24874 if (!SWIG_IsOK(ecode2)) {
24875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24876 }
24877 arg2 = static_cast< wxDateTime::Country >(val2);
24878 }
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (int)(arg1)->IsDST(arg2);
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_From_int(static_cast< int >(result));
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *resultobj = 0;
24894 wxDateTime *arg1 = (wxDateTime *) 0 ;
24895 bool result;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 PyObject *swig_obj[1] ;
24899
24900 if (!args) SWIG_fail;
24901 swig_obj[0] = args;
24902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24905 }
24906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (bool)((wxDateTime const *)arg1)->IsValid();
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24923 PyObject *resultobj = 0;
24924 wxDateTime *arg1 = (wxDateTime *) 0 ;
24925 time_t result;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 PyObject *swig_obj[1] ;
24929
24930 if (!args) SWIG_fail;
24931 swig_obj[0] = args;
24932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24933 if (!SWIG_IsOK(res1)) {
24934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24935 }
24936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24951 PyObject *resultobj = 0;
24952 wxDateTime *arg1 = (wxDateTime *) 0 ;
24953 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24954 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24955 int result;
24956 void *argp1 = 0 ;
24957 int res1 = 0 ;
24958 bool temp2 = false ;
24959 PyObject * obj0 = 0 ;
24960 PyObject * obj1 = 0 ;
24961 char * kwnames[] = {
24962 (char *) "self",(char *) "tz", NULL
24963 };
24964
24965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24969 }
24970 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24971 if (obj1) {
24972 {
24973 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24974 temp2 = true;
24975 }
24976 }
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_From_int(static_cast< int >(result));
24984 {
24985 if (temp2) delete arg2;
24986 }
24987 return resultobj;
24988 fail:
24989 {
24990 if (temp2) delete arg2;
24991 }
24992 return NULL;
24993 }
24994
24995
24996 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj = 0;
24998 wxDateTime *arg1 = (wxDateTime *) 0 ;
24999 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25000 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25001 wxDateTime::Month result;
25002 void *argp1 = 0 ;
25003 int res1 = 0 ;
25004 bool temp2 = false ;
25005 PyObject * obj0 = 0 ;
25006 PyObject * obj1 = 0 ;
25007 char * kwnames[] = {
25008 (char *) "self",(char *) "tz", NULL
25009 };
25010
25011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25013 if (!SWIG_IsOK(res1)) {
25014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25015 }
25016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25017 if (obj1) {
25018 {
25019 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25020 temp2 = true;
25021 }
25022 }
25023 {
25024 PyThreadState* __tstate = wxPyBeginAllowThreads();
25025 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25026 wxPyEndAllowThreads(__tstate);
25027 if (PyErr_Occurred()) SWIG_fail;
25028 }
25029 resultobj = SWIG_From_int(static_cast< int >(result));
25030 {
25031 if (temp2) delete arg2;
25032 }
25033 return resultobj;
25034 fail:
25035 {
25036 if (temp2) delete arg2;
25037 }
25038 return NULL;
25039 }
25040
25041
25042 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25043 PyObject *resultobj = 0;
25044 wxDateTime *arg1 = (wxDateTime *) 0 ;
25045 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25046 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25047 int result;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 bool temp2 = false ;
25051 PyObject * obj0 = 0 ;
25052 PyObject * obj1 = 0 ;
25053 char * kwnames[] = {
25054 (char *) "self",(char *) "tz", NULL
25055 };
25056
25057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25063 if (obj1) {
25064 {
25065 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25066 temp2 = true;
25067 }
25068 }
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_From_int(static_cast< int >(result));
25076 {
25077 if (temp2) delete arg2;
25078 }
25079 return resultobj;
25080 fail:
25081 {
25082 if (temp2) delete arg2;
25083 }
25084 return NULL;
25085 }
25086
25087
25088 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25089 PyObject *resultobj = 0;
25090 wxDateTime *arg1 = (wxDateTime *) 0 ;
25091 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25092 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25093 wxDateTime::WeekDay result;
25094 void *argp1 = 0 ;
25095 int res1 = 0 ;
25096 bool temp2 = false ;
25097 PyObject * obj0 = 0 ;
25098 PyObject * obj1 = 0 ;
25099 char * kwnames[] = {
25100 (char *) "self",(char *) "tz", NULL
25101 };
25102
25103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25105 if (!SWIG_IsOK(res1)) {
25106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25107 }
25108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25109 if (obj1) {
25110 {
25111 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25112 temp2 = true;
25113 }
25114 }
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 resultobj = SWIG_From_int(static_cast< int >(result));
25122 {
25123 if (temp2) delete arg2;
25124 }
25125 return resultobj;
25126 fail:
25127 {
25128 if (temp2) delete arg2;
25129 }
25130 return NULL;
25131 }
25132
25133
25134 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj = 0;
25136 wxDateTime *arg1 = (wxDateTime *) 0 ;
25137 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25138 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25139 int result;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 bool temp2 = false ;
25143 PyObject * obj0 = 0 ;
25144 PyObject * obj1 = 0 ;
25145 char * kwnames[] = {
25146 (char *) "self",(char *) "tz", NULL
25147 };
25148
25149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25153 }
25154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25155 if (obj1) {
25156 {
25157 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25158 temp2 = true;
25159 }
25160 }
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 resultobj = SWIG_From_int(static_cast< int >(result));
25168 {
25169 if (temp2) delete arg2;
25170 }
25171 return resultobj;
25172 fail:
25173 {
25174 if (temp2) delete arg2;
25175 }
25176 return NULL;
25177 }
25178
25179
25180 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25181 PyObject *resultobj = 0;
25182 wxDateTime *arg1 = (wxDateTime *) 0 ;
25183 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25184 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25185 int result;
25186 void *argp1 = 0 ;
25187 int res1 = 0 ;
25188 bool temp2 = false ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char * kwnames[] = {
25192 (char *) "self",(char *) "tz", NULL
25193 };
25194
25195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25197 if (!SWIG_IsOK(res1)) {
25198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25199 }
25200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25201 if (obj1) {
25202 {
25203 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25204 temp2 = true;
25205 }
25206 }
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 resultobj = SWIG_From_int(static_cast< int >(result));
25214 {
25215 if (temp2) delete arg2;
25216 }
25217 return resultobj;
25218 fail:
25219 {
25220 if (temp2) delete arg2;
25221 }
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj = 0;
25228 wxDateTime *arg1 = (wxDateTime *) 0 ;
25229 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25230 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25231 int result;
25232 void *argp1 = 0 ;
25233 int res1 = 0 ;
25234 bool temp2 = false ;
25235 PyObject * obj0 = 0 ;
25236 PyObject * obj1 = 0 ;
25237 char * kwnames[] = {
25238 (char *) "self",(char *) "tz", NULL
25239 };
25240
25241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25243 if (!SWIG_IsOK(res1)) {
25244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25245 }
25246 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25247 if (obj1) {
25248 {
25249 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25250 temp2 = true;
25251 }
25252 }
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_From_int(static_cast< int >(result));
25260 {
25261 if (temp2) delete arg2;
25262 }
25263 return resultobj;
25264 fail:
25265 {
25266 if (temp2) delete arg2;
25267 }
25268 return NULL;
25269 }
25270
25271
25272 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25273 PyObject *resultobj = 0;
25274 wxDateTime *arg1 = (wxDateTime *) 0 ;
25275 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25276 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25277 int result;
25278 void *argp1 = 0 ;
25279 int res1 = 0 ;
25280 bool temp2 = false ;
25281 PyObject * obj0 = 0 ;
25282 PyObject * obj1 = 0 ;
25283 char * kwnames[] = {
25284 (char *) "self",(char *) "tz", NULL
25285 };
25286
25287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25291 }
25292 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25293 if (obj1) {
25294 {
25295 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25296 temp2 = true;
25297 }
25298 }
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 resultobj = SWIG_From_int(static_cast< int >(result));
25306 {
25307 if (temp2) delete arg2;
25308 }
25309 return resultobj;
25310 fail:
25311 {
25312 if (temp2) delete arg2;
25313 }
25314 return NULL;
25315 }
25316
25317
25318 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25319 PyObject *resultobj = 0;
25320 wxDateTime *arg1 = (wxDateTime *) 0 ;
25321 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25322 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25323 int result;
25324 void *argp1 = 0 ;
25325 int res1 = 0 ;
25326 bool temp2 = false ;
25327 PyObject * obj0 = 0 ;
25328 PyObject * obj1 = 0 ;
25329 char * kwnames[] = {
25330 (char *) "self",(char *) "tz", NULL
25331 };
25332
25333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25335 if (!SWIG_IsOK(res1)) {
25336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25337 }
25338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25339 if (obj1) {
25340 {
25341 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25342 temp2 = true;
25343 }
25344 }
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 resultobj = SWIG_From_int(static_cast< int >(result));
25352 {
25353 if (temp2) delete arg2;
25354 }
25355 return resultobj;
25356 fail:
25357 {
25358 if (temp2) delete arg2;
25359 }
25360 return NULL;
25361 }
25362
25363
25364 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj = 0;
25366 wxDateTime *arg1 = (wxDateTime *) 0 ;
25367 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25368 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25369 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25370 int result;
25371 void *argp1 = 0 ;
25372 int res1 = 0 ;
25373 int val2 ;
25374 int ecode2 = 0 ;
25375 bool temp3 = false ;
25376 PyObject * obj0 = 0 ;
25377 PyObject * obj1 = 0 ;
25378 PyObject * obj2 = 0 ;
25379 char * kwnames[] = {
25380 (char *) "self",(char *) "flags",(char *) "tz", NULL
25381 };
25382
25383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25387 }
25388 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25389 if (obj1) {
25390 ecode2 = SWIG_AsVal_int(obj1, &val2);
25391 if (!SWIG_IsOK(ecode2)) {
25392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25393 }
25394 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25395 }
25396 if (obj2) {
25397 {
25398 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25399 temp3 = true;
25400 }
25401 }
25402 {
25403 PyThreadState* __tstate = wxPyBeginAllowThreads();
25404 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 resultobj = SWIG_From_int(static_cast< int >(result));
25409 {
25410 if (temp3) delete arg3;
25411 }
25412 return resultobj;
25413 fail:
25414 {
25415 if (temp3) delete arg3;
25416 }
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj = 0;
25423 wxDateTime *arg1 = (wxDateTime *) 0 ;
25424 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25425 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25426 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25427 int result;
25428 void *argp1 = 0 ;
25429 int res1 = 0 ;
25430 int val2 ;
25431 int ecode2 = 0 ;
25432 bool temp3 = false ;
25433 PyObject * obj0 = 0 ;
25434 PyObject * obj1 = 0 ;
25435 PyObject * obj2 = 0 ;
25436 char * kwnames[] = {
25437 (char *) "self",(char *) "flags",(char *) "tz", NULL
25438 };
25439
25440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25444 }
25445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25446 if (obj1) {
25447 ecode2 = SWIG_AsVal_int(obj1, &val2);
25448 if (!SWIG_IsOK(ecode2)) {
25449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25450 }
25451 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25452 }
25453 if (obj2) {
25454 {
25455 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25456 temp3 = true;
25457 }
25458 }
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 resultobj = SWIG_From_int(static_cast< int >(result));
25466 {
25467 if (temp3) delete arg3;
25468 }
25469 return resultobj;
25470 fail:
25471 {
25472 if (temp3) delete arg3;
25473 }
25474 return NULL;
25475 }
25476
25477
25478 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj = 0;
25480 wxDateTime *arg1 = (wxDateTime *) 0 ;
25481 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25482 bool result;
25483 void *argp1 = 0 ;
25484 int res1 = 0 ;
25485 int val2 ;
25486 int ecode2 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 char * kwnames[] = {
25490 (char *) "self",(char *) "country", NULL
25491 };
25492
25493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25495 if (!SWIG_IsOK(res1)) {
25496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25497 }
25498 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25499 if (obj1) {
25500 ecode2 = SWIG_AsVal_int(obj1, &val2);
25501 if (!SWIG_IsOK(ecode2)) {
25502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25503 }
25504 arg2 = static_cast< wxDateTime::Country >(val2);
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 {
25513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25514 }
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj = 0;
25523 wxDateTime *arg1 = (wxDateTime *) 0 ;
25524 wxDateTime *arg2 = 0 ;
25525 bool result;
25526 void *argp1 = 0 ;
25527 int res1 = 0 ;
25528 void *argp2 = 0 ;
25529 int res2 = 0 ;
25530 PyObject * obj0 = 0 ;
25531 PyObject * obj1 = 0 ;
25532 char * kwnames[] = {
25533 (char *) "self",(char *) "datetime", NULL
25534 };
25535
25536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25538 if (!SWIG_IsOK(res1)) {
25539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25540 }
25541 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25542 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25543 if (!SWIG_IsOK(res2)) {
25544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25545 }
25546 if (!argp2) {
25547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25548 }
25549 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25550 {
25551 PyThreadState* __tstate = wxPyBeginAllowThreads();
25552 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25553 wxPyEndAllowThreads(__tstate);
25554 if (PyErr_Occurred()) SWIG_fail;
25555 }
25556 {
25557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25558 }
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25566 PyObject *resultobj = 0;
25567 wxDateTime *arg1 = (wxDateTime *) 0 ;
25568 wxDateTime *arg2 = 0 ;
25569 bool result;
25570 void *argp1 = 0 ;
25571 int res1 = 0 ;
25572 void *argp2 = 0 ;
25573 int res2 = 0 ;
25574 PyObject * obj0 = 0 ;
25575 PyObject * obj1 = 0 ;
25576 char * kwnames[] = {
25577 (char *) "self",(char *) "datetime", NULL
25578 };
25579
25580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25582 if (!SWIG_IsOK(res1)) {
25583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25584 }
25585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25586 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25587 if (!SWIG_IsOK(res2)) {
25588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25589 }
25590 if (!argp2) {
25591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25592 }
25593 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25602 }
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxDateTime *arg1 = (wxDateTime *) 0 ;
25612 wxDateTime *arg2 = 0 ;
25613 bool result;
25614 void *argp1 = 0 ;
25615 int res1 = 0 ;
25616 void *argp2 = 0 ;
25617 int res2 = 0 ;
25618 PyObject * obj0 = 0 ;
25619 PyObject * obj1 = 0 ;
25620 char * kwnames[] = {
25621 (char *) "self",(char *) "datetime", NULL
25622 };
25623
25624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25626 if (!SWIG_IsOK(res1)) {
25627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25628 }
25629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25631 if (!SWIG_IsOK(res2)) {
25632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25633 }
25634 if (!argp2) {
25635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25636 }
25637 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25638 {
25639 PyThreadState* __tstate = wxPyBeginAllowThreads();
25640 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25641 wxPyEndAllowThreads(__tstate);
25642 if (PyErr_Occurred()) SWIG_fail;
25643 }
25644 {
25645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25646 }
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = 0;
25655 wxDateTime *arg1 = (wxDateTime *) 0 ;
25656 wxDateTime *arg2 = 0 ;
25657 wxDateTime *arg3 = 0 ;
25658 bool result;
25659 void *argp1 = 0 ;
25660 int res1 = 0 ;
25661 void *argp2 = 0 ;
25662 int res2 = 0 ;
25663 void *argp3 = 0 ;
25664 int res3 = 0 ;
25665 PyObject * obj0 = 0 ;
25666 PyObject * obj1 = 0 ;
25667 PyObject * obj2 = 0 ;
25668 char * kwnames[] = {
25669 (char *) "self",(char *) "t1",(char *) "t2", NULL
25670 };
25671
25672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25674 if (!SWIG_IsOK(res1)) {
25675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25676 }
25677 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25679 if (!SWIG_IsOK(res2)) {
25680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25681 }
25682 if (!argp2) {
25683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25684 }
25685 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25686 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25687 if (!SWIG_IsOK(res3)) {
25688 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25689 }
25690 if (!argp3) {
25691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25692 }
25693 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 {
25701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25702 }
25703 return resultobj;
25704 fail:
25705 return NULL;
25706 }
25707
25708
25709 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25710 PyObject *resultobj = 0;
25711 wxDateTime *arg1 = (wxDateTime *) 0 ;
25712 wxDateTime *arg2 = 0 ;
25713 wxDateTime *arg3 = 0 ;
25714 bool result;
25715 void *argp1 = 0 ;
25716 int res1 = 0 ;
25717 void *argp2 = 0 ;
25718 int res2 = 0 ;
25719 void *argp3 = 0 ;
25720 int res3 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 PyObject * obj2 = 0 ;
25724 char * kwnames[] = {
25725 (char *) "self",(char *) "t1",(char *) "t2", NULL
25726 };
25727
25728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25730 if (!SWIG_IsOK(res1)) {
25731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25732 }
25733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25735 if (!SWIG_IsOK(res2)) {
25736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25737 }
25738 if (!argp2) {
25739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25740 }
25741 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25742 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25743 if (!SWIG_IsOK(res3)) {
25744 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25745 }
25746 if (!argp3) {
25747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25748 }
25749 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25750 {
25751 PyThreadState* __tstate = wxPyBeginAllowThreads();
25752 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25753 wxPyEndAllowThreads(__tstate);
25754 if (PyErr_Occurred()) SWIG_fail;
25755 }
25756 {
25757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25758 }
25759 return resultobj;
25760 fail:
25761 return NULL;
25762 }
25763
25764
25765 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25766 PyObject *resultobj = 0;
25767 wxDateTime *arg1 = (wxDateTime *) 0 ;
25768 wxDateTime *arg2 = 0 ;
25769 bool result;
25770 void *argp1 = 0 ;
25771 int res1 = 0 ;
25772 void *argp2 = 0 ;
25773 int res2 = 0 ;
25774 PyObject * obj0 = 0 ;
25775 PyObject * obj1 = 0 ;
25776 char * kwnames[] = {
25777 (char *) "self",(char *) "dt", NULL
25778 };
25779
25780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25782 if (!SWIG_IsOK(res1)) {
25783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25784 }
25785 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25787 if (!SWIG_IsOK(res2)) {
25788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25789 }
25790 if (!argp2) {
25791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25792 }
25793 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 {
25801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25802 }
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj = 0;
25811 wxDateTime *arg1 = (wxDateTime *) 0 ;
25812 wxDateTime *arg2 = 0 ;
25813 bool result;
25814 void *argp1 = 0 ;
25815 int res1 = 0 ;
25816 void *argp2 = 0 ;
25817 int res2 = 0 ;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 char * kwnames[] = {
25821 (char *) "self",(char *) "dt", NULL
25822 };
25823
25824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25828 }
25829 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25830 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25831 if (!SWIG_IsOK(res2)) {
25832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25833 }
25834 if (!argp2) {
25835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25836 }
25837 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 {
25845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25846 }
25847 return resultobj;
25848 fail:
25849 return NULL;
25850 }
25851
25852
25853 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25854 PyObject *resultobj = 0;
25855 wxDateTime *arg1 = (wxDateTime *) 0 ;
25856 wxDateTime *arg2 = 0 ;
25857 wxTimeSpan *arg3 = 0 ;
25858 bool result;
25859 void *argp1 = 0 ;
25860 int res1 = 0 ;
25861 void *argp2 = 0 ;
25862 int res2 = 0 ;
25863 void *argp3 = 0 ;
25864 int res3 = 0 ;
25865 PyObject * obj0 = 0 ;
25866 PyObject * obj1 = 0 ;
25867 PyObject * obj2 = 0 ;
25868 char * kwnames[] = {
25869 (char *) "self",(char *) "dt",(char *) "ts", NULL
25870 };
25871
25872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25874 if (!SWIG_IsOK(res1)) {
25875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25876 }
25877 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25878 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25879 if (!SWIG_IsOK(res2)) {
25880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25881 }
25882 if (!argp2) {
25883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25884 }
25885 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25886 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25887 if (!SWIG_IsOK(res3)) {
25888 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25889 }
25890 if (!argp3) {
25891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25892 }
25893 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 {
25901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25902 }
25903 return resultobj;
25904 fail:
25905 return NULL;
25906 }
25907
25908
25909 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj = 0;
25911 wxDateTime *arg1 = (wxDateTime *) 0 ;
25912 wxTimeSpan *arg2 = 0 ;
25913 wxDateTime *result = 0 ;
25914 void *argp1 = 0 ;
25915 int res1 = 0 ;
25916 void *argp2 = 0 ;
25917 int res2 = 0 ;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "self",(char *) "diff", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25928 }
25929 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25931 if (!SWIG_IsOK(res2)) {
25932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25933 }
25934 if (!argp2) {
25935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25936 }
25937 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 {
25941 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25942 result = (wxDateTime *) &_result_ref;
25943 }
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25955 PyObject *resultobj = 0;
25956 wxDateTime *arg1 = (wxDateTime *) 0 ;
25957 wxDateSpan *arg2 = 0 ;
25958 wxDateTime *result = 0 ;
25959 void *argp1 = 0 ;
25960 int res1 = 0 ;
25961 void *argp2 = 0 ;
25962 int res2 = 0 ;
25963 PyObject * obj0 = 0 ;
25964 PyObject * obj1 = 0 ;
25965 char * kwnames[] = {
25966 (char *) "self",(char *) "diff", NULL
25967 };
25968
25969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25971 if (!SWIG_IsOK(res1)) {
25972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25973 }
25974 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25976 if (!SWIG_IsOK(res2)) {
25977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25978 }
25979 if (!argp2) {
25980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25981 }
25982 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25983 {
25984 PyThreadState* __tstate = wxPyBeginAllowThreads();
25985 {
25986 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25987 result = (wxDateTime *) &_result_ref;
25988 }
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxDateTime *arg1 = (wxDateTime *) 0 ;
26002 wxTimeSpan *arg2 = 0 ;
26003 wxDateTime *result = 0 ;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 void *argp2 = 0 ;
26007 int res2 = 0 ;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char * kwnames[] = {
26011 (char *) "self",(char *) "diff", NULL
26012 };
26013
26014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26018 }
26019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26021 if (!SWIG_IsOK(res2)) {
26022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26023 }
26024 if (!argp2) {
26025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26026 }
26027 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 {
26031 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26032 result = (wxDateTime *) &_result_ref;
26033 }
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj = 0;
26046 wxDateTime *arg1 = (wxDateTime *) 0 ;
26047 wxDateSpan *arg2 = 0 ;
26048 wxDateTime *result = 0 ;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 void *argp2 = 0 ;
26052 int res2 = 0 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 char * kwnames[] = {
26056 (char *) "self",(char *) "diff", NULL
26057 };
26058
26059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26061 if (!SWIG_IsOK(res1)) {
26062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26063 }
26064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26066 if (!SWIG_IsOK(res2)) {
26067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26068 }
26069 if (!argp2) {
26070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26071 }
26072 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26073 {
26074 PyThreadState* __tstate = wxPyBeginAllowThreads();
26075 {
26076 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26077 result = (wxDateTime *) &_result_ref;
26078 }
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj = 0;
26091 wxDateTime *arg1 = (wxDateTime *) 0 ;
26092 wxDateTime *arg2 = 0 ;
26093 wxTimeSpan result;
26094 void *argp1 = 0 ;
26095 int res1 = 0 ;
26096 void *argp2 = 0 ;
26097 int res2 = 0 ;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char * kwnames[] = {
26101 (char *) "self",(char *) "dt", NULL
26102 };
26103
26104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26106 if (!SWIG_IsOK(res1)) {
26107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26108 }
26109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26111 if (!SWIG_IsOK(res2)) {
26112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26113 }
26114 if (!argp2) {
26115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26116 }
26117 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26121 wxPyEndAllowThreads(__tstate);
26122 if (PyErr_Occurred()) SWIG_fail;
26123 }
26124 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26125 return resultobj;
26126 fail:
26127 return NULL;
26128 }
26129
26130
26131 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26132 PyObject *resultobj = 0;
26133 wxDateTime *arg1 = (wxDateTime *) 0 ;
26134 wxTimeSpan *arg2 = 0 ;
26135 wxDateTime *result = 0 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 void *argp2 = 0 ;
26139 int res2 = 0 ;
26140
26141 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26145 }
26146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26147 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26148 if (!SWIG_IsOK(res2)) {
26149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26150 }
26151 if (!argp2) {
26152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26153 }
26154 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26155 {
26156 PyThreadState* __tstate = wxPyBeginAllowThreads();
26157 {
26158 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26159 result = (wxDateTime *) &_result_ref;
26160 }
26161 wxPyEndAllowThreads(__tstate);
26162 if (PyErr_Occurred()) SWIG_fail;
26163 }
26164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26172 PyObject *resultobj = 0;
26173 wxDateTime *arg1 = (wxDateTime *) 0 ;
26174 wxDateSpan *arg2 = 0 ;
26175 wxDateTime *result = 0 ;
26176 void *argp1 = 0 ;
26177 int res1 = 0 ;
26178 void *argp2 = 0 ;
26179 int res2 = 0 ;
26180
26181 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26183 if (!SWIG_IsOK(res1)) {
26184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26185 }
26186 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26187 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26188 if (!SWIG_IsOK(res2)) {
26189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26190 }
26191 if (!argp2) {
26192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26193 }
26194 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 {
26198 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26199 result = (wxDateTime *) &_result_ref;
26200 }
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26212 int argc;
26213 PyObject *argv[3];
26214
26215 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26216 --argc;
26217 if (argc == 2) {
26218 int _v = 0;
26219 {
26220 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26221 _v = SWIG_CheckState(res);
26222 }
26223 if (!_v) goto check_1;
26224 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26225 }
26226 check_1:
26227
26228 if (argc == 2) {
26229 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26230 }
26231
26232 fail:
26233 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26239 PyObject *resultobj = 0;
26240 wxDateTime *arg1 = (wxDateTime *) 0 ;
26241 wxTimeSpan *arg2 = 0 ;
26242 wxDateTime *result = 0 ;
26243 void *argp1 = 0 ;
26244 int res1 = 0 ;
26245 void *argp2 = 0 ;
26246 int res2 = 0 ;
26247
26248 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26250 if (!SWIG_IsOK(res1)) {
26251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26252 }
26253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26254 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26255 if (!SWIG_IsOK(res2)) {
26256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26257 }
26258 if (!argp2) {
26259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26260 }
26261 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26262 {
26263 PyThreadState* __tstate = wxPyBeginAllowThreads();
26264 {
26265 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26266 result = (wxDateTime *) &_result_ref;
26267 }
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26279 PyObject *resultobj = 0;
26280 wxDateTime *arg1 = (wxDateTime *) 0 ;
26281 wxDateSpan *arg2 = 0 ;
26282 wxDateTime *result = 0 ;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 void *argp2 = 0 ;
26286 int res2 = 0 ;
26287
26288 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26292 }
26293 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26294 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26295 if (!SWIG_IsOK(res2)) {
26296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26297 }
26298 if (!argp2) {
26299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26300 }
26301 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26302 {
26303 PyThreadState* __tstate = wxPyBeginAllowThreads();
26304 {
26305 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26306 result = (wxDateTime *) &_result_ref;
26307 }
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26319 int argc;
26320 PyObject *argv[3];
26321
26322 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26323 --argc;
26324 if (argc == 2) {
26325 int _v = 0;
26326 {
26327 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26328 _v = SWIG_CheckState(res);
26329 }
26330 if (!_v) goto check_1;
26331 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26332 }
26333 check_1:
26334
26335 if (argc == 2) {
26336 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26337 }
26338
26339 fail:
26340 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26341 return NULL;
26342 }
26343
26344
26345 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26346 PyObject *resultobj = 0;
26347 wxDateTime *arg1 = (wxDateTime *) 0 ;
26348 wxTimeSpan *arg2 = 0 ;
26349 wxDateTime result;
26350 void *argp1 = 0 ;
26351 int res1 = 0 ;
26352 void *argp2 = 0 ;
26353 int res2 = 0 ;
26354
26355 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26359 }
26360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26362 if (!SWIG_IsOK(res2)) {
26363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26364 }
26365 if (!argp2) {
26366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26367 }
26368 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26383 PyObject *resultobj = 0;
26384 wxDateTime *arg1 = (wxDateTime *) 0 ;
26385 wxDateSpan *arg2 = 0 ;
26386 wxDateTime result;
26387 void *argp1 = 0 ;
26388 int res1 = 0 ;
26389 void *argp2 = 0 ;
26390 int res2 = 0 ;
26391
26392 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26394 if (!SWIG_IsOK(res1)) {
26395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26396 }
26397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26398 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26399 if (!SWIG_IsOK(res2)) {
26400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26401 }
26402 if (!argp2) {
26403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26404 }
26405 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26413 return resultobj;
26414 fail:
26415 return NULL;
26416 }
26417
26418
26419 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26420 int argc;
26421 PyObject *argv[3];
26422
26423 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26424 --argc;
26425 if (argc == 2) {
26426 int _v = 0;
26427 {
26428 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26429 _v = SWIG_CheckState(res);
26430 }
26431 if (!_v) goto check_1;
26432 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26433 }
26434 check_1:
26435
26436 if (argc == 2) {
26437 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26438 }
26439
26440 fail:
26441 Py_INCREF(Py_NotImplemented);
26442 return Py_NotImplemented;
26443 }
26444
26445
26446 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26447 PyObject *resultobj = 0;
26448 wxDateTime *arg1 = (wxDateTime *) 0 ;
26449 wxDateTime *arg2 = 0 ;
26450 wxTimeSpan result;
26451 void *argp1 = 0 ;
26452 int res1 = 0 ;
26453 void *argp2 = 0 ;
26454 int res2 = 0 ;
26455
26456 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26458 if (!SWIG_IsOK(res1)) {
26459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26460 }
26461 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26462 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26463 if (!SWIG_IsOK(res2)) {
26464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26465 }
26466 if (!argp2) {
26467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26468 }
26469 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26484 PyObject *resultobj = 0;
26485 wxDateTime *arg1 = (wxDateTime *) 0 ;
26486 wxTimeSpan *arg2 = 0 ;
26487 wxDateTime result;
26488 void *argp1 = 0 ;
26489 int res1 = 0 ;
26490 void *argp2 = 0 ;
26491 int res2 = 0 ;
26492
26493 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26495 if (!SWIG_IsOK(res1)) {
26496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26497 }
26498 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26499 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26500 if (!SWIG_IsOK(res2)) {
26501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26502 }
26503 if (!argp2) {
26504 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26505 }
26506 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26514 return resultobj;
26515 fail:
26516 return NULL;
26517 }
26518
26519
26520 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26521 PyObject *resultobj = 0;
26522 wxDateTime *arg1 = (wxDateTime *) 0 ;
26523 wxDateSpan *arg2 = 0 ;
26524 wxDateTime result;
26525 void *argp1 = 0 ;
26526 int res1 = 0 ;
26527 void *argp2 = 0 ;
26528 int res2 = 0 ;
26529
26530 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26534 }
26535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26536 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26537 if (!SWIG_IsOK(res2)) {
26538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26539 }
26540 if (!argp2) {
26541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26542 }
26543 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26551 return resultobj;
26552 fail:
26553 return NULL;
26554 }
26555
26556
26557 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26558 int argc;
26559 PyObject *argv[3];
26560
26561 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26562 --argc;
26563 if (argc == 2) {
26564 int _v = 0;
26565 {
26566 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26567 _v = SWIG_CheckState(res);
26568 }
26569 if (!_v) goto check_1;
26570 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26571 }
26572 check_1:
26573
26574 if (argc == 2) {
26575 int _v = 0;
26576 {
26577 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26578 _v = SWIG_CheckState(res);
26579 }
26580 if (!_v) goto check_2;
26581 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26582 }
26583 check_2:
26584
26585 if (argc == 2) {
26586 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26587 }
26588
26589 fail:
26590 Py_INCREF(Py_NotImplemented);
26591 return Py_NotImplemented;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxDateTime *arg1 = (wxDateTime *) 0 ;
26598 wxDateTime *arg2 = (wxDateTime *) 0 ;
26599 bool result;
26600 void *argp1 = 0 ;
26601 int res1 = 0 ;
26602 void *argp2 = 0 ;
26603 int res2 = 0 ;
26604 PyObject * obj0 = 0 ;
26605 PyObject * obj1 = 0 ;
26606 char * kwnames[] = {
26607 (char *) "self",(char *) "other", NULL
26608 };
26609
26610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26612 if (!SWIG_IsOK(res1)) {
26613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26614 }
26615 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26617 if (!SWIG_IsOK(res2)) {
26618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26619 }
26620 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 {
26628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26629 }
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxDateTime *arg1 = (wxDateTime *) 0 ;
26639 wxDateTime *arg2 = (wxDateTime *) 0 ;
26640 bool result;
26641 void *argp1 = 0 ;
26642 int res1 = 0 ;
26643 void *argp2 = 0 ;
26644 int res2 = 0 ;
26645 PyObject * obj0 = 0 ;
26646 PyObject * obj1 = 0 ;
26647 char * kwnames[] = {
26648 (char *) "self",(char *) "other", NULL
26649 };
26650
26651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26653 if (!SWIG_IsOK(res1)) {
26654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26655 }
26656 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26658 if (!SWIG_IsOK(res2)) {
26659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26660 }
26661 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26662 {
26663 PyThreadState* __tstate = wxPyBeginAllowThreads();
26664 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26665 wxPyEndAllowThreads(__tstate);
26666 if (PyErr_Occurred()) SWIG_fail;
26667 }
26668 {
26669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26670 }
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26678 PyObject *resultobj = 0;
26679 wxDateTime *arg1 = (wxDateTime *) 0 ;
26680 wxDateTime *arg2 = (wxDateTime *) 0 ;
26681 bool result;
26682 void *argp1 = 0 ;
26683 int res1 = 0 ;
26684 void *argp2 = 0 ;
26685 int res2 = 0 ;
26686 PyObject * obj0 = 0 ;
26687 PyObject * obj1 = 0 ;
26688 char * kwnames[] = {
26689 (char *) "self",(char *) "other", NULL
26690 };
26691
26692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26694 if (!SWIG_IsOK(res1)) {
26695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26696 }
26697 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26699 if (!SWIG_IsOK(res2)) {
26700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26701 }
26702 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26706 wxPyEndAllowThreads(__tstate);
26707 if (PyErr_Occurred()) SWIG_fail;
26708 }
26709 {
26710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26711 }
26712 return resultobj;
26713 fail:
26714 return NULL;
26715 }
26716
26717
26718 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26719 PyObject *resultobj = 0;
26720 wxDateTime *arg1 = (wxDateTime *) 0 ;
26721 wxDateTime *arg2 = (wxDateTime *) 0 ;
26722 bool result;
26723 void *argp1 = 0 ;
26724 int res1 = 0 ;
26725 void *argp2 = 0 ;
26726 int res2 = 0 ;
26727 PyObject * obj0 = 0 ;
26728 PyObject * obj1 = 0 ;
26729 char * kwnames[] = {
26730 (char *) "self",(char *) "other", NULL
26731 };
26732
26733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26735 if (!SWIG_IsOK(res1)) {
26736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26737 }
26738 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26740 if (!SWIG_IsOK(res2)) {
26741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26742 }
26743 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 {
26751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26752 }
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = 0;
26761 wxDateTime *arg1 = (wxDateTime *) 0 ;
26762 wxDateTime *arg2 = (wxDateTime *) 0 ;
26763 bool result;
26764 void *argp1 = 0 ;
26765 int res1 = 0 ;
26766 void *argp2 = 0 ;
26767 int res2 = 0 ;
26768 PyObject * obj0 = 0 ;
26769 PyObject * obj1 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "self",(char *) "other", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26776 if (!SWIG_IsOK(res1)) {
26777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26778 }
26779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26781 if (!SWIG_IsOK(res2)) {
26782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26783 }
26784 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 {
26792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793 }
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj = 0;
26802 wxDateTime *arg1 = (wxDateTime *) 0 ;
26803 wxDateTime *arg2 = (wxDateTime *) 0 ;
26804 bool result;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 void *argp2 = 0 ;
26808 int res2 = 0 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "other", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26822 if (!SWIG_IsOK(res2)) {
26823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26824 }
26825 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26829 wxPyEndAllowThreads(__tstate);
26830 if (PyErr_Occurred()) SWIG_fail;
26831 }
26832 {
26833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26834 }
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxDateTime *arg1 = (wxDateTime *) 0 ;
26844 wxString *arg2 = 0 ;
26845 int result;
26846 void *argp1 = 0 ;
26847 int res1 = 0 ;
26848 bool temp2 = false ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 char * kwnames[] = {
26852 (char *) "self",(char *) "date", NULL
26853 };
26854
26855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26857 if (!SWIG_IsOK(res1)) {
26858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26859 }
26860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26861 {
26862 arg2 = wxString_in_helper(obj1);
26863 if (arg2 == NULL) SWIG_fail;
26864 temp2 = true;
26865 }
26866 {
26867 PyThreadState* __tstate = wxPyBeginAllowThreads();
26868 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 resultobj = SWIG_From_int(static_cast< int >(result));
26873 {
26874 if (temp2)
26875 delete arg2;
26876 }
26877 return resultobj;
26878 fail:
26879 {
26880 if (temp2)
26881 delete arg2;
26882 }
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj = 0;
26889 wxDateTime *arg1 = (wxDateTime *) 0 ;
26890 wxString *arg2 = 0 ;
26891 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26892 wxString *arg3 = (wxString *) &arg3_defvalue ;
26893 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26894 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26895 int result;
26896 void *argp1 = 0 ;
26897 int res1 = 0 ;
26898 bool temp2 = false ;
26899 bool temp3 = false ;
26900 void *argp4 = 0 ;
26901 int res4 = 0 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 PyObject * obj2 = 0 ;
26905 PyObject * obj3 = 0 ;
26906 char * kwnames[] = {
26907 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26908 };
26909
26910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26912 if (!SWIG_IsOK(res1)) {
26913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26914 }
26915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26916 {
26917 arg2 = wxString_in_helper(obj1);
26918 if (arg2 == NULL) SWIG_fail;
26919 temp2 = true;
26920 }
26921 if (obj2) {
26922 {
26923 arg3 = wxString_in_helper(obj2);
26924 if (arg3 == NULL) SWIG_fail;
26925 temp3 = true;
26926 }
26927 }
26928 if (obj3) {
26929 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26930 if (!SWIG_IsOK(res4)) {
26931 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26932 }
26933 if (!argp4) {
26934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26935 }
26936 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26937 }
26938 {
26939 PyThreadState* __tstate = wxPyBeginAllowThreads();
26940 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 resultobj = SWIG_From_int(static_cast< int >(result));
26945 {
26946 if (temp2)
26947 delete arg2;
26948 }
26949 {
26950 if (temp3)
26951 delete arg3;
26952 }
26953 return resultobj;
26954 fail:
26955 {
26956 if (temp2)
26957 delete arg2;
26958 }
26959 {
26960 if (temp3)
26961 delete arg3;
26962 }
26963 return NULL;
26964 }
26965
26966
26967 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj = 0;
26969 wxDateTime *arg1 = (wxDateTime *) 0 ;
26970 wxString *arg2 = 0 ;
26971 int result;
26972 void *argp1 = 0 ;
26973 int res1 = 0 ;
26974 bool temp2 = false ;
26975 PyObject * obj0 = 0 ;
26976 PyObject * obj1 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "self",(char *) "datetime", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26983 if (!SWIG_IsOK(res1)) {
26984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26985 }
26986 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26987 {
26988 arg2 = wxString_in_helper(obj1);
26989 if (arg2 == NULL) SWIG_fail;
26990 temp2 = true;
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26995 wxPyEndAllowThreads(__tstate);
26996 if (PyErr_Occurred()) SWIG_fail;
26997 }
26998 resultobj = SWIG_From_int(static_cast< int >(result));
26999 {
27000 if (temp2)
27001 delete arg2;
27002 }
27003 return resultobj;
27004 fail:
27005 {
27006 if (temp2)
27007 delete arg2;
27008 }
27009 return NULL;
27010 }
27011
27012
27013 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27014 PyObject *resultobj = 0;
27015 wxDateTime *arg1 = (wxDateTime *) 0 ;
27016 wxString *arg2 = 0 ;
27017 int result;
27018 void *argp1 = 0 ;
27019 int res1 = 0 ;
27020 bool temp2 = false ;
27021 PyObject * obj0 = 0 ;
27022 PyObject * obj1 = 0 ;
27023 char * kwnames[] = {
27024 (char *) "self",(char *) "date", NULL
27025 };
27026
27027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27031 }
27032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27033 {
27034 arg2 = wxString_in_helper(obj1);
27035 if (arg2 == NULL) SWIG_fail;
27036 temp2 = true;
27037 }
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 resultobj = SWIG_From_int(static_cast< int >(result));
27045 {
27046 if (temp2)
27047 delete arg2;
27048 }
27049 return resultobj;
27050 fail:
27051 {
27052 if (temp2)
27053 delete arg2;
27054 }
27055 return NULL;
27056 }
27057
27058
27059 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27060 PyObject *resultobj = 0;
27061 wxDateTime *arg1 = (wxDateTime *) 0 ;
27062 wxString *arg2 = 0 ;
27063 int result;
27064 void *argp1 = 0 ;
27065 int res1 = 0 ;
27066 bool temp2 = false ;
27067 PyObject * obj0 = 0 ;
27068 PyObject * obj1 = 0 ;
27069 char * kwnames[] = {
27070 (char *) "self",(char *) "time", NULL
27071 };
27072
27073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27075 if (!SWIG_IsOK(res1)) {
27076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27077 }
27078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27079 {
27080 arg2 = wxString_in_helper(obj1);
27081 if (arg2 == NULL) SWIG_fail;
27082 temp2 = true;
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = SWIG_From_int(static_cast< int >(result));
27091 {
27092 if (temp2)
27093 delete arg2;
27094 }
27095 return resultobj;
27096 fail:
27097 {
27098 if (temp2)
27099 delete arg2;
27100 }
27101 return NULL;
27102 }
27103
27104
27105 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27106 PyObject *resultobj = 0;
27107 wxDateTime *arg1 = (wxDateTime *) 0 ;
27108 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27109 wxString *arg2 = (wxString *) &arg2_defvalue ;
27110 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27111 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27112 wxString result;
27113 void *argp1 = 0 ;
27114 int res1 = 0 ;
27115 bool temp2 = false ;
27116 bool temp3 = false ;
27117 PyObject * obj0 = 0 ;
27118 PyObject * obj1 = 0 ;
27119 PyObject * obj2 = 0 ;
27120 char * kwnames[] = {
27121 (char *) "self",(char *) "format",(char *) "tz", NULL
27122 };
27123
27124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27126 if (!SWIG_IsOK(res1)) {
27127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27128 }
27129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27130 if (obj1) {
27131 {
27132 arg2 = wxString_in_helper(obj1);
27133 if (arg2 == NULL) SWIG_fail;
27134 temp2 = true;
27135 }
27136 }
27137 if (obj2) {
27138 {
27139 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27140 temp3 = true;
27141 }
27142 }
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 {
27150 #if wxUSE_UNICODE
27151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27152 #else
27153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27154 #endif
27155 }
27156 {
27157 if (temp2)
27158 delete arg2;
27159 }
27160 {
27161 if (temp3) delete arg3;
27162 }
27163 return resultobj;
27164 fail:
27165 {
27166 if (temp2)
27167 delete arg2;
27168 }
27169 {
27170 if (temp3) delete arg3;
27171 }
27172 return NULL;
27173 }
27174
27175
27176 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27177 PyObject *resultobj = 0;
27178 wxDateTime *arg1 = (wxDateTime *) 0 ;
27179 wxString result;
27180 void *argp1 = 0 ;
27181 int res1 = 0 ;
27182 PyObject *swig_obj[1] ;
27183
27184 if (!args) SWIG_fail;
27185 swig_obj[0] = args;
27186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27187 if (!SWIG_IsOK(res1)) {
27188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27189 }
27190 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 result = ((wxDateTime const *)arg1)->FormatDate();
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 #if wxUSE_UNICODE
27199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27200 #else
27201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27202 #endif
27203 }
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27211 PyObject *resultobj = 0;
27212 wxDateTime *arg1 = (wxDateTime *) 0 ;
27213 wxString result;
27214 void *argp1 = 0 ;
27215 int res1 = 0 ;
27216 PyObject *swig_obj[1] ;
27217
27218 if (!args) SWIG_fail;
27219 swig_obj[0] = args;
27220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27223 }
27224 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = ((wxDateTime const *)arg1)->FormatTime();
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 #if wxUSE_UNICODE
27233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27234 #else
27235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27236 #endif
27237 }
27238 return resultobj;
27239 fail:
27240 return NULL;
27241 }
27242
27243
27244 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27245 PyObject *resultobj = 0;
27246 wxDateTime *arg1 = (wxDateTime *) 0 ;
27247 wxString result;
27248 void *argp1 = 0 ;
27249 int res1 = 0 ;
27250 PyObject *swig_obj[1] ;
27251
27252 if (!args) SWIG_fail;
27253 swig_obj[0] = args;
27254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27257 }
27258 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 result = ((wxDateTime const *)arg1)->FormatISODate();
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 {
27266 #if wxUSE_UNICODE
27267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27268 #else
27269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27270 #endif
27271 }
27272 return resultobj;
27273 fail:
27274 return NULL;
27275 }
27276
27277
27278 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27279 PyObject *resultobj = 0;
27280 wxDateTime *arg1 = (wxDateTime *) 0 ;
27281 wxString result;
27282 void *argp1 = 0 ;
27283 int res1 = 0 ;
27284 PyObject *swig_obj[1] ;
27285
27286 if (!args) SWIG_fail;
27287 swig_obj[0] = args;
27288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27289 if (!SWIG_IsOK(res1)) {
27290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27291 }
27292 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 result = ((wxDateTime const *)arg1)->FormatISOTime();
27296 wxPyEndAllowThreads(__tstate);
27297 if (PyErr_Occurred()) SWIG_fail;
27298 }
27299 {
27300 #if wxUSE_UNICODE
27301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27302 #else
27303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27304 #endif
27305 }
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27313 PyObject *obj;
27314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27315 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27316 return SWIG_Py_Void();
27317 }
27318
27319 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27320 return SWIG_Python_InitShadowInstance(args);
27321 }
27322
27323 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27324 PyObject *resultobj = 0;
27325 long arg1 ;
27326 wxTimeSpan result;
27327 long val1 ;
27328 int ecode1 = 0 ;
27329 PyObject * obj0 = 0 ;
27330 char * kwnames[] = {
27331 (char *) "ms", NULL
27332 };
27333
27334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27335 ecode1 = SWIG_AsVal_long(obj0, &val1);
27336 if (!SWIG_IsOK(ecode1)) {
27337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27338 }
27339 arg1 = static_cast< long >(val1);
27340 {
27341 PyThreadState* __tstate = wxPyBeginAllowThreads();
27342 result = wxTimeSpan::Milliseconds(arg1);
27343 wxPyEndAllowThreads(__tstate);
27344 if (PyErr_Occurred()) SWIG_fail;
27345 }
27346 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27347 return resultobj;
27348 fail:
27349 return NULL;
27350 }
27351
27352
27353 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 PyObject *resultobj = 0;
27355 wxTimeSpan result;
27356
27357 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 result = wxTimeSpan::Millisecond();
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = 0;
27373 long arg1 ;
27374 wxTimeSpan result;
27375 long val1 ;
27376 int ecode1 = 0 ;
27377 PyObject * obj0 = 0 ;
27378 char * kwnames[] = {
27379 (char *) "sec", NULL
27380 };
27381
27382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27383 ecode1 = SWIG_AsVal_long(obj0, &val1);
27384 if (!SWIG_IsOK(ecode1)) {
27385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27386 }
27387 arg1 = static_cast< long >(val1);
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = wxTimeSpan::Seconds(arg1);
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 PyObject *resultobj = 0;
27403 wxTimeSpan result;
27404
27405 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27406 {
27407 PyThreadState* __tstate = wxPyBeginAllowThreads();
27408 result = wxTimeSpan::Second();
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27420 PyObject *resultobj = 0;
27421 long arg1 ;
27422 wxTimeSpan result;
27423 long val1 ;
27424 int ecode1 = 0 ;
27425 PyObject * obj0 = 0 ;
27426 char * kwnames[] = {
27427 (char *) "min", NULL
27428 };
27429
27430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27431 ecode1 = SWIG_AsVal_long(obj0, &val1);
27432 if (!SWIG_IsOK(ecode1)) {
27433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27434 }
27435 arg1 = static_cast< long >(val1);
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 result = wxTimeSpan::Minutes(arg1);
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27450 PyObject *resultobj = 0;
27451 wxTimeSpan result;
27452
27453 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = wxTimeSpan::Minute();
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27461 return resultobj;
27462 fail:
27463 return NULL;
27464 }
27465
27466
27467 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27468 PyObject *resultobj = 0;
27469 long arg1 ;
27470 wxTimeSpan result;
27471 long val1 ;
27472 int ecode1 = 0 ;
27473 PyObject * obj0 = 0 ;
27474 char * kwnames[] = {
27475 (char *) "hours", NULL
27476 };
27477
27478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27479 ecode1 = SWIG_AsVal_long(obj0, &val1);
27480 if (!SWIG_IsOK(ecode1)) {
27481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27482 }
27483 arg1 = static_cast< long >(val1);
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 result = wxTimeSpan::Hours(arg1);
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxTimeSpan result;
27500
27501 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 result = wxTimeSpan::Hour();
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27516 PyObject *resultobj = 0;
27517 long arg1 ;
27518 wxTimeSpan result;
27519 long val1 ;
27520 int ecode1 = 0 ;
27521 PyObject * obj0 = 0 ;
27522 char * kwnames[] = {
27523 (char *) "days", NULL
27524 };
27525
27526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27527 ecode1 = SWIG_AsVal_long(obj0, &val1);
27528 if (!SWIG_IsOK(ecode1)) {
27529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27530 }
27531 arg1 = static_cast< long >(val1);
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 result = wxTimeSpan::Days(arg1);
27535 wxPyEndAllowThreads(__tstate);
27536 if (PyErr_Occurred()) SWIG_fail;
27537 }
27538 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27546 PyObject *resultobj = 0;
27547 wxTimeSpan result;
27548
27549 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 result = wxTimeSpan::Day();
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27564 PyObject *resultobj = 0;
27565 long arg1 ;
27566 wxTimeSpan result;
27567 long val1 ;
27568 int ecode1 = 0 ;
27569 PyObject * obj0 = 0 ;
27570 char * kwnames[] = {
27571 (char *) "days", NULL
27572 };
27573
27574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27575 ecode1 = SWIG_AsVal_long(obj0, &val1);
27576 if (!SWIG_IsOK(ecode1)) {
27577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27578 }
27579 arg1 = static_cast< long >(val1);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = wxTimeSpan::Weeks(arg1);
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27594 PyObject *resultobj = 0;
27595 wxTimeSpan result;
27596
27597 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = wxTimeSpan::Week();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 long arg1 = (long) 0 ;
27614 long arg2 = (long) 0 ;
27615 long arg3 = (long) 0 ;
27616 long arg4 = (long) 0 ;
27617 wxTimeSpan *result = 0 ;
27618 long val1 ;
27619 int ecode1 = 0 ;
27620 long val2 ;
27621 int ecode2 = 0 ;
27622 long val3 ;
27623 int ecode3 = 0 ;
27624 long val4 ;
27625 int ecode4 = 0 ;
27626 PyObject * obj0 = 0 ;
27627 PyObject * obj1 = 0 ;
27628 PyObject * obj2 = 0 ;
27629 PyObject * obj3 = 0 ;
27630 char * kwnames[] = {
27631 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27632 };
27633
27634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27635 if (obj0) {
27636 ecode1 = SWIG_AsVal_long(obj0, &val1);
27637 if (!SWIG_IsOK(ecode1)) {
27638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27639 }
27640 arg1 = static_cast< long >(val1);
27641 }
27642 if (obj1) {
27643 ecode2 = SWIG_AsVal_long(obj1, &val2);
27644 if (!SWIG_IsOK(ecode2)) {
27645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27646 }
27647 arg2 = static_cast< long >(val2);
27648 }
27649 if (obj2) {
27650 ecode3 = SWIG_AsVal_long(obj2, &val3);
27651 if (!SWIG_IsOK(ecode3)) {
27652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27653 }
27654 arg3 = static_cast< long >(val3);
27655 }
27656 if (obj3) {
27657 ecode4 = SWIG_AsVal_long(obj3, &val4);
27658 if (!SWIG_IsOK(ecode4)) {
27659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27660 }
27661 arg4 = static_cast< long >(val4);
27662 }
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27666 wxPyEndAllowThreads(__tstate);
27667 if (PyErr_Occurred()) SWIG_fail;
27668 }
27669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27670 return resultobj;
27671 fail:
27672 return NULL;
27673 }
27674
27675
27676 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27677 PyObject *resultobj = 0;
27678 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27679 void *argp1 = 0 ;
27680 int res1 = 0 ;
27681 PyObject *swig_obj[1] ;
27682
27683 if (!args) SWIG_fail;
27684 swig_obj[0] = args;
27685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27686 if (!SWIG_IsOK(res1)) {
27687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27688 }
27689 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 delete arg1;
27693
27694 wxPyEndAllowThreads(__tstate);
27695 if (PyErr_Occurred()) SWIG_fail;
27696 }
27697 resultobj = SWIG_Py_Void();
27698 return resultobj;
27699 fail:
27700 return NULL;
27701 }
27702
27703
27704 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27705 PyObject *resultobj = 0;
27706 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27707 wxTimeSpan *arg2 = 0 ;
27708 wxTimeSpan *result = 0 ;
27709 void *argp1 = 0 ;
27710 int res1 = 0 ;
27711 void *argp2 = 0 ;
27712 int res2 = 0 ;
27713 PyObject * obj0 = 0 ;
27714 PyObject * obj1 = 0 ;
27715 char * kwnames[] = {
27716 (char *) "self",(char *) "diff", NULL
27717 };
27718
27719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27723 }
27724 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27726 if (!SWIG_IsOK(res2)) {
27727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27728 }
27729 if (!argp2) {
27730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27731 }
27732 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 {
27736 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27737 result = (wxTimeSpan *) &_result_ref;
27738 }
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27750 PyObject *resultobj = 0;
27751 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27752 wxTimeSpan *arg2 = 0 ;
27753 wxTimeSpan *result = 0 ;
27754 void *argp1 = 0 ;
27755 int res1 = 0 ;
27756 void *argp2 = 0 ;
27757 int res2 = 0 ;
27758 PyObject * obj0 = 0 ;
27759 PyObject * obj1 = 0 ;
27760 char * kwnames[] = {
27761 (char *) "self",(char *) "diff", NULL
27762 };
27763
27764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27766 if (!SWIG_IsOK(res1)) {
27767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27768 }
27769 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27771 if (!SWIG_IsOK(res2)) {
27772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27773 }
27774 if (!argp2) {
27775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27776 }
27777 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 {
27781 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27782 result = (wxTimeSpan *) &_result_ref;
27783 }
27784 wxPyEndAllowThreads(__tstate);
27785 if (PyErr_Occurred()) SWIG_fail;
27786 }
27787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27795 PyObject *resultobj = 0;
27796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27797 int arg2 ;
27798 wxTimeSpan *result = 0 ;
27799 void *argp1 = 0 ;
27800 int res1 = 0 ;
27801 int val2 ;
27802 int ecode2 = 0 ;
27803 PyObject * obj0 = 0 ;
27804 PyObject * obj1 = 0 ;
27805 char * kwnames[] = {
27806 (char *) "self",(char *) "n", NULL
27807 };
27808
27809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27811 if (!SWIG_IsOK(res1)) {
27812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27813 }
27814 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27815 ecode2 = SWIG_AsVal_int(obj1, &val2);
27816 if (!SWIG_IsOK(ecode2)) {
27817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27818 }
27819 arg2 = static_cast< int >(val2);
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 {
27823 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27824 result = (wxTimeSpan *) &_result_ref;
27825 }
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27837 PyObject *resultobj = 0;
27838 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27839 wxTimeSpan *result = 0 ;
27840 void *argp1 = 0 ;
27841 int res1 = 0 ;
27842 PyObject *swig_obj[1] ;
27843
27844 if (!args) SWIG_fail;
27845 swig_obj[0] = args;
27846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27849 }
27850 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 {
27854 wxTimeSpan &_result_ref = (arg1)->Neg();
27855 result = (wxTimeSpan *) &_result_ref;
27856 }
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27870 wxTimeSpan result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = ((wxTimeSpan const *)arg1)->Abs();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj = 0;
27897 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27898 wxTimeSpan *arg2 = 0 ;
27899 wxTimeSpan *result = 0 ;
27900 void *argp1 = 0 ;
27901 int res1 = 0 ;
27902 void *argp2 = 0 ;
27903 int res2 = 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 char * kwnames[] = {
27907 (char *) "self",(char *) "diff", NULL
27908 };
27909
27910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27914 }
27915 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27917 if (!SWIG_IsOK(res2)) {
27918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27919 }
27920 if (!argp2) {
27921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27922 }
27923 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 {
27927 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27928 result = (wxTimeSpan *) &_result_ref;
27929 }
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj = 0;
27942 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27943 wxTimeSpan *arg2 = 0 ;
27944 wxTimeSpan *result = 0 ;
27945 void *argp1 = 0 ;
27946 int res1 = 0 ;
27947 void *argp2 = 0 ;
27948 int res2 = 0 ;
27949 PyObject * obj0 = 0 ;
27950 PyObject * obj1 = 0 ;
27951 char * kwnames[] = {
27952 (char *) "self",(char *) "diff", NULL
27953 };
27954
27955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27957 if (!SWIG_IsOK(res1)) {
27958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27959 }
27960 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27962 if (!SWIG_IsOK(res2)) {
27963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27964 }
27965 if (!argp2) {
27966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27967 }
27968 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 {
27972 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27973 result = (wxTimeSpan *) &_result_ref;
27974 }
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27988 int arg2 ;
27989 wxTimeSpan *result = 0 ;
27990 void *argp1 = 0 ;
27991 int res1 = 0 ;
27992 int val2 ;
27993 int ecode2 = 0 ;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char * kwnames[] = {
27997 (char *) "self",(char *) "n", NULL
27998 };
27999
28000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28004 }
28005 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28006 ecode2 = SWIG_AsVal_int(obj1, &val2);
28007 if (!SWIG_IsOK(ecode2)) {
28008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28009 }
28010 arg2 = static_cast< int >(val2);
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 {
28014 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28015 result = (wxTimeSpan *) &_result_ref;
28016 }
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28028 PyObject *resultobj = 0;
28029 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28030 wxTimeSpan *result = 0 ;
28031 void *argp1 = 0 ;
28032 int res1 = 0 ;
28033 PyObject *swig_obj[1] ;
28034
28035 if (!args) SWIG_fail;
28036 swig_obj[0] = args;
28037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28038 if (!SWIG_IsOK(res1)) {
28039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28040 }
28041 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 {
28045 wxTimeSpan &_result_ref = (arg1)->operator -();
28046 result = (wxTimeSpan *) &_result_ref;
28047 }
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28061 wxTimeSpan *arg2 = 0 ;
28062 wxTimeSpan result;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 void *argp2 = 0 ;
28066 int res2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "other", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28077 }
28078 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28080 if (!SWIG_IsOK(res2)) {
28081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28082 }
28083 if (!argp2) {
28084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28085 }
28086 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28090 wxPyEndAllowThreads(__tstate);
28091 if (PyErr_Occurred()) SWIG_fail;
28092 }
28093 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28094 return resultobj;
28095 fail:
28096 return NULL;
28097 }
28098
28099
28100 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj = 0;
28102 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28103 wxTimeSpan *arg2 = 0 ;
28104 wxTimeSpan result;
28105 void *argp1 = 0 ;
28106 int res1 = 0 ;
28107 void *argp2 = 0 ;
28108 int res2 = 0 ;
28109 PyObject * obj0 = 0 ;
28110 PyObject * obj1 = 0 ;
28111 char * kwnames[] = {
28112 (char *) "self",(char *) "other", NULL
28113 };
28114
28115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28119 }
28120 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28122 if (!SWIG_IsOK(res2)) {
28123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28124 }
28125 if (!argp2) {
28126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28127 }
28128 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj = 0;
28144 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28145 int arg2 ;
28146 wxTimeSpan result;
28147 void *argp1 = 0 ;
28148 int res1 = 0 ;
28149 int val2 ;
28150 int ecode2 = 0 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char * kwnames[] = {
28154 (char *) "self",(char *) "n", NULL
28155 };
28156
28157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28159 if (!SWIG_IsOK(res1)) {
28160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28161 }
28162 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28163 ecode2 = SWIG_AsVal_int(obj1, &val2);
28164 if (!SWIG_IsOK(ecode2)) {
28165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28166 }
28167 arg2 = static_cast< int >(val2);
28168 {
28169 PyThreadState* __tstate = wxPyBeginAllowThreads();
28170 result = wxTimeSpan___mul__(arg1,arg2);
28171 wxPyEndAllowThreads(__tstate);
28172 if (PyErr_Occurred()) SWIG_fail;
28173 }
28174 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28175 return resultobj;
28176 fail:
28177 return NULL;
28178 }
28179
28180
28181 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28182 PyObject *resultobj = 0;
28183 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28184 int arg2 ;
28185 wxTimeSpan result;
28186 void *argp1 = 0 ;
28187 int res1 = 0 ;
28188 int val2 ;
28189 int ecode2 = 0 ;
28190 PyObject * obj0 = 0 ;
28191 PyObject * obj1 = 0 ;
28192 char * kwnames[] = {
28193 (char *) "self",(char *) "n", NULL
28194 };
28195
28196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28198 if (!SWIG_IsOK(res1)) {
28199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28200 }
28201 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28202 ecode2 = SWIG_AsVal_int(obj1, &val2);
28203 if (!SWIG_IsOK(ecode2)) {
28204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28205 }
28206 arg2 = static_cast< int >(val2);
28207 {
28208 PyThreadState* __tstate = wxPyBeginAllowThreads();
28209 result = wxTimeSpan___rmul__(arg1,arg2);
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28214 return resultobj;
28215 fail:
28216 return NULL;
28217 }
28218
28219
28220 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28221 PyObject *resultobj = 0;
28222 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28223 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28224 bool result;
28225 void *argp1 = 0 ;
28226 int res1 = 0 ;
28227 void *argp2 = 0 ;
28228 int res2 = 0 ;
28229 PyObject * obj0 = 0 ;
28230 PyObject * obj1 = 0 ;
28231 char * kwnames[] = {
28232 (char *) "self",(char *) "other", NULL
28233 };
28234
28235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28237 if (!SWIG_IsOK(res1)) {
28238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28239 }
28240 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28242 if (!SWIG_IsOK(res2)) {
28243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28244 }
28245 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28249 wxPyEndAllowThreads(__tstate);
28250 if (PyErr_Occurred()) SWIG_fail;
28251 }
28252 {
28253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28254 }
28255 return resultobj;
28256 fail:
28257 return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28262 PyObject *resultobj = 0;
28263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28264 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28265 bool result;
28266 void *argp1 = 0 ;
28267 int res1 = 0 ;
28268 void *argp2 = 0 ;
28269 int res2 = 0 ;
28270 PyObject * obj0 = 0 ;
28271 PyObject * obj1 = 0 ;
28272 char * kwnames[] = {
28273 (char *) "self",(char *) "other", NULL
28274 };
28275
28276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28278 if (!SWIG_IsOK(res1)) {
28279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28280 }
28281 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28283 if (!SWIG_IsOK(res2)) {
28284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28285 }
28286 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28287 {
28288 PyThreadState* __tstate = wxPyBeginAllowThreads();
28289 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28290 wxPyEndAllowThreads(__tstate);
28291 if (PyErr_Occurred()) SWIG_fail;
28292 }
28293 {
28294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28295 }
28296 return resultobj;
28297 fail:
28298 return NULL;
28299 }
28300
28301
28302 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28303 PyObject *resultobj = 0;
28304 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28305 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28306 bool result;
28307 void *argp1 = 0 ;
28308 int res1 = 0 ;
28309 void *argp2 = 0 ;
28310 int res2 = 0 ;
28311 PyObject * obj0 = 0 ;
28312 PyObject * obj1 = 0 ;
28313 char * kwnames[] = {
28314 (char *) "self",(char *) "other", NULL
28315 };
28316
28317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28319 if (!SWIG_IsOK(res1)) {
28320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28321 }
28322 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28324 if (!SWIG_IsOK(res2)) {
28325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28326 }
28327 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 {
28335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28336 }
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28344 PyObject *resultobj = 0;
28345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28346 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28347 bool result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 void *argp2 = 0 ;
28351 int res2 = 0 ;
28352 PyObject * obj0 = 0 ;
28353 PyObject * obj1 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "self",(char *) "other", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28360 if (!SWIG_IsOK(res1)) {
28361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28362 }
28363 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28365 if (!SWIG_IsOK(res2)) {
28366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28367 }
28368 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 {
28376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28377 }
28378 return resultobj;
28379 fail:
28380 return NULL;
28381 }
28382
28383
28384 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28385 PyObject *resultobj = 0;
28386 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28387 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28388 bool result;
28389 void *argp1 = 0 ;
28390 int res1 = 0 ;
28391 void *argp2 = 0 ;
28392 int res2 = 0 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 char * kwnames[] = {
28396 (char *) "self",(char *) "other", NULL
28397 };
28398
28399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28403 }
28404 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28406 if (!SWIG_IsOK(res2)) {
28407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28408 }
28409 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28410 {
28411 PyThreadState* __tstate = wxPyBeginAllowThreads();
28412 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 {
28417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28418 }
28419 return resultobj;
28420 fail:
28421 return NULL;
28422 }
28423
28424
28425 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28426 PyObject *resultobj = 0;
28427 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28428 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28429 bool result;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 void *argp2 = 0 ;
28433 int res2 = 0 ;
28434 PyObject * obj0 = 0 ;
28435 PyObject * obj1 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "self",(char *) "other", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28444 }
28445 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28447 if (!SWIG_IsOK(res2)) {
28448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28449 }
28450 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 {
28458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28467 PyObject *resultobj = 0;
28468 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28469 bool result;
28470 void *argp1 = 0 ;
28471 int res1 = 0 ;
28472 PyObject *swig_obj[1] ;
28473
28474 if (!args) SWIG_fail;
28475 swig_obj[0] = args;
28476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28479 }
28480 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 {
28488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28489 }
28490 return resultobj;
28491 fail:
28492 return NULL;
28493 }
28494
28495
28496 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28497 PyObject *resultobj = 0;
28498 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28499 bool result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 PyObject *swig_obj[1] ;
28503
28504 if (!args) SWIG_fail;
28505 swig_obj[0] = args;
28506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28509 }
28510 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28519 }
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28527 PyObject *resultobj = 0;
28528 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28529 bool result;
28530 void *argp1 = 0 ;
28531 int res1 = 0 ;
28532 PyObject *swig_obj[1] ;
28533
28534 if (!args) SWIG_fail;
28535 swig_obj[0] = args;
28536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28537 if (!SWIG_IsOK(res1)) {
28538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28539 }
28540 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 {
28548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28549 }
28550 return resultobj;
28551 fail:
28552 return NULL;
28553 }
28554
28555
28556 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28557 PyObject *resultobj = 0;
28558 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28559 wxTimeSpan *arg2 = 0 ;
28560 bool result;
28561 void *argp1 = 0 ;
28562 int res1 = 0 ;
28563 void *argp2 = 0 ;
28564 int res2 = 0 ;
28565 PyObject * obj0 = 0 ;
28566 PyObject * obj1 = 0 ;
28567 char * kwnames[] = {
28568 (char *) "self",(char *) "ts", NULL
28569 };
28570
28571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28573 if (!SWIG_IsOK(res1)) {
28574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28575 }
28576 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28578 if (!SWIG_IsOK(res2)) {
28579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28580 }
28581 if (!argp2) {
28582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28583 }
28584 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 {
28592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28593 }
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28601 PyObject *resultobj = 0;
28602 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28603 wxTimeSpan *arg2 = 0 ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 void *argp2 = 0 ;
28608 int res2 = 0 ;
28609 PyObject * obj0 = 0 ;
28610 PyObject * obj1 = 0 ;
28611 char * kwnames[] = {
28612 (char *) "self",(char *) "ts", NULL
28613 };
28614
28615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28617 if (!SWIG_IsOK(res1)) {
28618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28619 }
28620 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28622 if (!SWIG_IsOK(res2)) {
28623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28624 }
28625 if (!argp2) {
28626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28627 }
28628 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 {
28636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28637 }
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28645 PyObject *resultobj = 0;
28646 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28647 wxTimeSpan *arg2 = 0 ;
28648 bool result;
28649 void *argp1 = 0 ;
28650 int res1 = 0 ;
28651 void *argp2 = 0 ;
28652 int res2 = 0 ;
28653 PyObject * obj0 = 0 ;
28654 PyObject * obj1 = 0 ;
28655 char * kwnames[] = {
28656 (char *) "self",(char *) "t", NULL
28657 };
28658
28659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28661 if (!SWIG_IsOK(res1)) {
28662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28663 }
28664 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28665 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28666 if (!SWIG_IsOK(res2)) {
28667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28668 }
28669 if (!argp2) {
28670 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28671 }
28672 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28673 {
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 {
28680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28681 }
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28691 int result;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 PyObject *swig_obj[1] ;
28695
28696 if (!args) SWIG_fail;
28697 swig_obj[0] = args;
28698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 resultobj = SWIG_From_int(static_cast< int >(result));
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28717 PyObject *resultobj = 0;
28718 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28719 int result;
28720 void *argp1 = 0 ;
28721 int res1 = 0 ;
28722 PyObject *swig_obj[1] ;
28723
28724 if (!args) SWIG_fail;
28725 swig_obj[0] = args;
28726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28727 if (!SWIG_IsOK(res1)) {
28728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28729 }
28730 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28731 {
28732 PyThreadState* __tstate = wxPyBeginAllowThreads();
28733 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 resultobj = SWIG_From_int(static_cast< int >(result));
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28745 PyObject *resultobj = 0;
28746 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28747 int result;
28748 void *argp1 = 0 ;
28749 int res1 = 0 ;
28750 PyObject *swig_obj[1] ;
28751
28752 if (!args) SWIG_fail;
28753 swig_obj[0] = args;
28754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28757 }
28758 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 resultobj = SWIG_From_int(static_cast< int >(result));
28766 return resultobj;
28767 fail:
28768 return NULL;
28769 }
28770
28771
28772 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28773 PyObject *resultobj = 0;
28774 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28775 int result;
28776 void *argp1 = 0 ;
28777 int res1 = 0 ;
28778 PyObject *swig_obj[1] ;
28779
28780 if (!args) SWIG_fail;
28781 swig_obj[0] = args;
28782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28783 if (!SWIG_IsOK(res1)) {
28784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28785 }
28786 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28787 {
28788 PyThreadState* __tstate = wxPyBeginAllowThreads();
28789 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 resultobj = SWIG_From_int(static_cast< int >(result));
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28801 PyObject *resultobj = 0;
28802 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28803 wxLongLong result;
28804 void *argp1 = 0 ;
28805 int res1 = 0 ;
28806 PyObject *swig_obj[1] ;
28807
28808 if (!args) SWIG_fail;
28809 swig_obj[0] = args;
28810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28811 if (!SWIG_IsOK(res1)) {
28812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28813 }
28814 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28818 wxPyEndAllowThreads(__tstate);
28819 if (PyErr_Occurred()) SWIG_fail;
28820 }
28821 {
28822 PyObject *hi, *lo, *shifter, *shifted;
28823 hi = PyLong_FromLong( (&result)->GetHi() );
28824 lo = PyLong_FromLong( (&result)->GetLo() );
28825 shifter = PyLong_FromLong(32);
28826 shifted = PyNumber_Lshift(hi, shifter);
28827 resultobj = PyNumber_Or(shifted, lo);
28828 Py_DECREF(hi);
28829 Py_DECREF(lo);
28830 Py_DECREF(shifter);
28831 Py_DECREF(shifted);
28832 }
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28842 wxLongLong result;
28843 void *argp1 = 0 ;
28844 int res1 = 0 ;
28845 PyObject *swig_obj[1] ;
28846
28847 if (!args) SWIG_fail;
28848 swig_obj[0] = args;
28849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28850 if (!SWIG_IsOK(res1)) {
28851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28852 }
28853 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 {
28861 PyObject *hi, *lo, *shifter, *shifted;
28862 hi = PyLong_FromLong( (&result)->GetHi() );
28863 lo = PyLong_FromLong( (&result)->GetLo() );
28864 shifter = PyLong_FromLong(32);
28865 shifted = PyNumber_Lshift(hi, shifter);
28866 resultobj = PyNumber_Or(shifted, lo);
28867 Py_DECREF(hi);
28868 Py_DECREF(lo);
28869 Py_DECREF(shifter);
28870 Py_DECREF(shifted);
28871 }
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28879 PyObject *resultobj = 0;
28880 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28881 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28882 wxString *arg2 = (wxString *) &arg2_defvalue ;
28883 wxString result;
28884 void *argp1 = 0 ;
28885 int res1 = 0 ;
28886 bool temp2 = false ;
28887 PyObject * obj0 = 0 ;
28888 PyObject * obj1 = 0 ;
28889 char * kwnames[] = {
28890 (char *) "self",(char *) "format", NULL
28891 };
28892
28893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28895 if (!SWIG_IsOK(res1)) {
28896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28897 }
28898 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28899 if (obj1) {
28900 {
28901 arg2 = wxString_in_helper(obj1);
28902 if (arg2 == NULL) SWIG_fail;
28903 temp2 = true;
28904 }
28905 }
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 {
28913 #if wxUSE_UNICODE
28914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28915 #else
28916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28917 #endif
28918 }
28919 {
28920 if (temp2)
28921 delete arg2;
28922 }
28923 return resultobj;
28924 fail:
28925 {
28926 if (temp2)
28927 delete arg2;
28928 }
28929 return NULL;
28930 }
28931
28932
28933 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28934 PyObject *obj;
28935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28936 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28937 return SWIG_Py_Void();
28938 }
28939
28940 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 return SWIG_Python_InitShadowInstance(args);
28942 }
28943
28944 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28945 PyObject *resultobj = 0;
28946 int arg1 = (int) 0 ;
28947 int arg2 = (int) 0 ;
28948 int arg3 = (int) 0 ;
28949 int arg4 = (int) 0 ;
28950 wxDateSpan *result = 0 ;
28951 int val1 ;
28952 int ecode1 = 0 ;
28953 int val2 ;
28954 int ecode2 = 0 ;
28955 int val3 ;
28956 int ecode3 = 0 ;
28957 int val4 ;
28958 int ecode4 = 0 ;
28959 PyObject * obj0 = 0 ;
28960 PyObject * obj1 = 0 ;
28961 PyObject * obj2 = 0 ;
28962 PyObject * obj3 = 0 ;
28963 char * kwnames[] = {
28964 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28965 };
28966
28967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28968 if (obj0) {
28969 ecode1 = SWIG_AsVal_int(obj0, &val1);
28970 if (!SWIG_IsOK(ecode1)) {
28971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28972 }
28973 arg1 = static_cast< int >(val1);
28974 }
28975 if (obj1) {
28976 ecode2 = SWIG_AsVal_int(obj1, &val2);
28977 if (!SWIG_IsOK(ecode2)) {
28978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28979 }
28980 arg2 = static_cast< int >(val2);
28981 }
28982 if (obj2) {
28983 ecode3 = SWIG_AsVal_int(obj2, &val3);
28984 if (!SWIG_IsOK(ecode3)) {
28985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28986 }
28987 arg3 = static_cast< int >(val3);
28988 }
28989 if (obj3) {
28990 ecode4 = SWIG_AsVal_int(obj3, &val4);
28991 if (!SWIG_IsOK(ecode4)) {
28992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28993 }
28994 arg4 = static_cast< int >(val4);
28995 }
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29010 PyObject *resultobj = 0;
29011 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 PyObject *swig_obj[1] ;
29015
29016 if (!args) SWIG_fail;
29017 swig_obj[0] = args;
29018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29019 if (!SWIG_IsOK(res1)) {
29020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29021 }
29022 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 delete arg1;
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_Py_Void();
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj = 0;
29039 int arg1 ;
29040 wxDateSpan result;
29041 int val1 ;
29042 int ecode1 = 0 ;
29043 PyObject * obj0 = 0 ;
29044 char * kwnames[] = {
29045 (char *) "days", NULL
29046 };
29047
29048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29049 ecode1 = SWIG_AsVal_int(obj0, &val1);
29050 if (!SWIG_IsOK(ecode1)) {
29051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29052 }
29053 arg1 = static_cast< int >(val1);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = wxDateSpan::Days(arg1);
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *resultobj = 0;
29069 wxDateSpan result;
29070
29071 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = wxDateSpan::Day();
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29079 return resultobj;
29080 fail:
29081 return NULL;
29082 }
29083
29084
29085 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29086 PyObject *resultobj = 0;
29087 int arg1 ;
29088 wxDateSpan result;
29089 int val1 ;
29090 int ecode1 = 0 ;
29091 PyObject * obj0 = 0 ;
29092 char * kwnames[] = {
29093 (char *) "weeks", NULL
29094 };
29095
29096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29097 ecode1 = SWIG_AsVal_int(obj0, &val1);
29098 if (!SWIG_IsOK(ecode1)) {
29099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29100 }
29101 arg1 = static_cast< int >(val1);
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = wxDateSpan::Weeks(arg1);
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 PyObject *resultobj = 0;
29117 wxDateSpan result;
29118
29119 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 result = wxDateSpan::Week();
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj = 0;
29135 int arg1 ;
29136 wxDateSpan result;
29137 int val1 ;
29138 int ecode1 = 0 ;
29139 PyObject * obj0 = 0 ;
29140 char * kwnames[] = {
29141 (char *) "mon", NULL
29142 };
29143
29144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29145 ecode1 = SWIG_AsVal_int(obj0, &val1);
29146 if (!SWIG_IsOK(ecode1)) {
29147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29148 }
29149 arg1 = static_cast< int >(val1);
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = wxDateSpan::Months(arg1);
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 PyObject *resultobj = 0;
29165 wxDateSpan result;
29166
29167 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 result = wxDateSpan::Month();
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj = 0;
29183 int arg1 ;
29184 wxDateSpan result;
29185 int val1 ;
29186 int ecode1 = 0 ;
29187 PyObject * obj0 = 0 ;
29188 char * kwnames[] = {
29189 (char *) "years", NULL
29190 };
29191
29192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29193 ecode1 = SWIG_AsVal_int(obj0, &val1);
29194 if (!SWIG_IsOK(ecode1)) {
29195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29196 }
29197 arg1 = static_cast< int >(val1);
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = wxDateSpan::Years(arg1);
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29212 PyObject *resultobj = 0;
29213 wxDateSpan result;
29214
29215 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 result = wxDateSpan::Year();
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj = 0;
29231 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29232 int arg2 ;
29233 wxDateSpan *result = 0 ;
29234 void *argp1 = 0 ;
29235 int res1 = 0 ;
29236 int val2 ;
29237 int ecode2 = 0 ;
29238 PyObject * obj0 = 0 ;
29239 PyObject * obj1 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "self",(char *) "n", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29246 if (!SWIG_IsOK(res1)) {
29247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29248 }
29249 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29250 ecode2 = SWIG_AsVal_int(obj1, &val2);
29251 if (!SWIG_IsOK(ecode2)) {
29252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29253 }
29254 arg2 = static_cast< int >(val2);
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 {
29258 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29259 result = (wxDateSpan *) &_result_ref;
29260 }
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj = 0;
29273 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29274 int arg2 ;
29275 wxDateSpan *result = 0 ;
29276 void *argp1 = 0 ;
29277 int res1 = 0 ;
29278 int val2 ;
29279 int ecode2 = 0 ;
29280 PyObject * obj0 = 0 ;
29281 PyObject * obj1 = 0 ;
29282 char * kwnames[] = {
29283 (char *) "self",(char *) "n", NULL
29284 };
29285
29286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29288 if (!SWIG_IsOK(res1)) {
29289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29290 }
29291 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29292 ecode2 = SWIG_AsVal_int(obj1, &val2);
29293 if (!SWIG_IsOK(ecode2)) {
29294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29295 }
29296 arg2 = static_cast< int >(val2);
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 {
29300 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29301 result = (wxDateSpan *) &_result_ref;
29302 }
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj = 0;
29315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29316 int arg2 ;
29317 wxDateSpan *result = 0 ;
29318 void *argp1 = 0 ;
29319 int res1 = 0 ;
29320 int val2 ;
29321 int ecode2 = 0 ;
29322 PyObject * obj0 = 0 ;
29323 PyObject * obj1 = 0 ;
29324 char * kwnames[] = {
29325 (char *) "self",(char *) "n", NULL
29326 };
29327
29328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29332 }
29333 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29334 ecode2 = SWIG_AsVal_int(obj1, &val2);
29335 if (!SWIG_IsOK(ecode2)) {
29336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29337 }
29338 arg2 = static_cast< int >(val2);
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 {
29342 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29343 result = (wxDateSpan *) &_result_ref;
29344 }
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj = 0;
29357 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29358 int arg2 ;
29359 wxDateSpan *result = 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 int val2 ;
29363 int ecode2 = 0 ;
29364 PyObject * obj0 = 0 ;
29365 PyObject * obj1 = 0 ;
29366 char * kwnames[] = {
29367 (char *) "self",(char *) "n", NULL
29368 };
29369
29370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29372 if (!SWIG_IsOK(res1)) {
29373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29374 }
29375 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29376 ecode2 = SWIG_AsVal_int(obj1, &val2);
29377 if (!SWIG_IsOK(ecode2)) {
29378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29379 }
29380 arg2 = static_cast< int >(val2);
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 {
29384 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29385 result = (wxDateSpan *) &_result_ref;
29386 }
29387 wxPyEndAllowThreads(__tstate);
29388 if (PyErr_Occurred()) SWIG_fail;
29389 }
29390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29391 return resultobj;
29392 fail:
29393 return NULL;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29398 PyObject *resultobj = 0;
29399 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29400 int result;
29401 void *argp1 = 0 ;
29402 int res1 = 0 ;
29403 PyObject *swig_obj[1] ;
29404
29405 if (!args) SWIG_fail;
29406 swig_obj[0] = args;
29407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29408 if (!SWIG_IsOK(res1)) {
29409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29410 }
29411 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 result = (int)((wxDateSpan const *)arg1)->GetYears();
29415 wxPyEndAllowThreads(__tstate);
29416 if (PyErr_Occurred()) SWIG_fail;
29417 }
29418 resultobj = SWIG_From_int(static_cast< int >(result));
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *resultobj = 0;
29427 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29428 int result;
29429 void *argp1 = 0 ;
29430 int res1 = 0 ;
29431 PyObject *swig_obj[1] ;
29432
29433 if (!args) SWIG_fail;
29434 swig_obj[0] = args;
29435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29436 if (!SWIG_IsOK(res1)) {
29437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29438 }
29439 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29440 {
29441 PyThreadState* __tstate = wxPyBeginAllowThreads();
29442 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_From_int(static_cast< int >(result));
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454 PyObject *resultobj = 0;
29455 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29456 int result;
29457 void *argp1 = 0 ;
29458 int res1 = 0 ;
29459 PyObject *swig_obj[1] ;
29460
29461 if (!args) SWIG_fail;
29462 swig_obj[0] = args;
29463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29464 if (!SWIG_IsOK(res1)) {
29465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29466 }
29467 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29468 {
29469 PyThreadState* __tstate = wxPyBeginAllowThreads();
29470 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29471 wxPyEndAllowThreads(__tstate);
29472 if (PyErr_Occurred()) SWIG_fail;
29473 }
29474 resultobj = SWIG_From_int(static_cast< int >(result));
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29482 PyObject *resultobj = 0;
29483 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29484 int result;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 PyObject *swig_obj[1] ;
29488
29489 if (!args) SWIG_fail;
29490 swig_obj[0] = args;
29491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29492 if (!SWIG_IsOK(res1)) {
29493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29494 }
29495 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (int)((wxDateSpan const *)arg1)->GetDays();
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_From_int(static_cast< int >(result));
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29510 PyObject *resultobj = 0;
29511 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29512 int result;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 PyObject *swig_obj[1] ;
29516
29517 if (!args) SWIG_fail;
29518 swig_obj[0] = args;
29519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29520 if (!SWIG_IsOK(res1)) {
29521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29522 }
29523 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 resultobj = SWIG_From_int(static_cast< int >(result));
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29538 PyObject *resultobj = 0;
29539 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29540 wxDateSpan *arg2 = 0 ;
29541 wxDateSpan *result = 0 ;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 void *argp2 = 0 ;
29545 int res2 = 0 ;
29546 PyObject * obj0 = 0 ;
29547 PyObject * obj1 = 0 ;
29548 char * kwnames[] = {
29549 (char *) "self",(char *) "other", NULL
29550 };
29551
29552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29556 }
29557 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29558 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29559 if (!SWIG_IsOK(res2)) {
29560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29561 }
29562 if (!argp2) {
29563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29564 }
29565 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 {
29569 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29570 result = (wxDateSpan *) &_result_ref;
29571 }
29572 wxPyEndAllowThreads(__tstate);
29573 if (PyErr_Occurred()) SWIG_fail;
29574 }
29575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29576 return resultobj;
29577 fail:
29578 return NULL;
29579 }
29580
29581
29582 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29583 PyObject *resultobj = 0;
29584 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29585 wxDateSpan *arg2 = 0 ;
29586 wxDateSpan *result = 0 ;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 void *argp2 = 0 ;
29590 int res2 = 0 ;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 char * kwnames[] = {
29594 (char *) "self",(char *) "other", NULL
29595 };
29596
29597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29599 if (!SWIG_IsOK(res1)) {
29600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29601 }
29602 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29604 if (!SWIG_IsOK(res2)) {
29605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29606 }
29607 if (!argp2) {
29608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29609 }
29610 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29611 {
29612 PyThreadState* __tstate = wxPyBeginAllowThreads();
29613 {
29614 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29615 result = (wxDateSpan *) &_result_ref;
29616 }
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 PyObject *resultobj = 0;
29629 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29630 wxDateSpan *result = 0 ;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject *swig_obj[1] ;
29634
29635 if (!args) SWIG_fail;
29636 swig_obj[0] = args;
29637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29640 }
29641 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 {
29645 wxDateSpan &_result_ref = (arg1)->Neg();
29646 result = (wxDateSpan *) &_result_ref;
29647 }
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29659 PyObject *resultobj = 0;
29660 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29661 int arg2 ;
29662 wxDateSpan *result = 0 ;
29663 void *argp1 = 0 ;
29664 int res1 = 0 ;
29665 int val2 ;
29666 int ecode2 = 0 ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 char * kwnames[] = {
29670 (char *) "self",(char *) "factor", NULL
29671 };
29672
29673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29677 }
29678 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29679 ecode2 = SWIG_AsVal_int(obj1, &val2);
29680 if (!SWIG_IsOK(ecode2)) {
29681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29682 }
29683 arg2 = static_cast< int >(val2);
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 {
29687 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29688 result = (wxDateSpan *) &_result_ref;
29689 }
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj = 0;
29702 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29703 wxDateSpan *arg2 = 0 ;
29704 wxDateSpan *result = 0 ;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 void *argp2 = 0 ;
29708 int res2 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "other", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29719 }
29720 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29722 if (!SWIG_IsOK(res2)) {
29723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29724 }
29725 if (!argp2) {
29726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29727 }
29728 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 {
29732 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29733 result = (wxDateSpan *) &_result_ref;
29734 }
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj = 0;
29747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29748 wxDateSpan *arg2 = 0 ;
29749 wxDateSpan *result = 0 ;
29750 void *argp1 = 0 ;
29751 int res1 = 0 ;
29752 void *argp2 = 0 ;
29753 int res2 = 0 ;
29754 PyObject * obj0 = 0 ;
29755 PyObject * obj1 = 0 ;
29756 char * kwnames[] = {
29757 (char *) "self",(char *) "other", NULL
29758 };
29759
29760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29762 if (!SWIG_IsOK(res1)) {
29763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29764 }
29765 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29767 if (!SWIG_IsOK(res2)) {
29768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29769 }
29770 if (!argp2) {
29771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29772 }
29773 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 {
29777 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29778 result = (wxDateSpan *) &_result_ref;
29779 }
29780 wxPyEndAllowThreads(__tstate);
29781 if (PyErr_Occurred()) SWIG_fail;
29782 }
29783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29784 return resultobj;
29785 fail:
29786 return NULL;
29787 }
29788
29789
29790 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29791 PyObject *resultobj = 0;
29792 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29793 wxDateSpan *result = 0 ;
29794 void *argp1 = 0 ;
29795 int res1 = 0 ;
29796 PyObject *swig_obj[1] ;
29797
29798 if (!args) SWIG_fail;
29799 swig_obj[0] = args;
29800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29801 if (!SWIG_IsOK(res1)) {
29802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29803 }
29804 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 {
29808 wxDateSpan &_result_ref = (arg1)->operator -();
29809 result = (wxDateSpan *) &_result_ref;
29810 }
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29815 return resultobj;
29816 fail:
29817 return NULL;
29818 }
29819
29820
29821 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29822 PyObject *resultobj = 0;
29823 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29824 int arg2 ;
29825 wxDateSpan *result = 0 ;
29826 void *argp1 = 0 ;
29827 int res1 = 0 ;
29828 int val2 ;
29829 int ecode2 = 0 ;
29830 PyObject * obj0 = 0 ;
29831 PyObject * obj1 = 0 ;
29832 char * kwnames[] = {
29833 (char *) "self",(char *) "factor", NULL
29834 };
29835
29836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29838 if (!SWIG_IsOK(res1)) {
29839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29840 }
29841 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29842 ecode2 = SWIG_AsVal_int(obj1, &val2);
29843 if (!SWIG_IsOK(ecode2)) {
29844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29845 }
29846 arg2 = static_cast< int >(val2);
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 {
29850 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29851 result = (wxDateSpan *) &_result_ref;
29852 }
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj = 0;
29865 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29866 wxDateSpan *arg2 = 0 ;
29867 wxDateSpan result;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 void *argp2 = 0 ;
29871 int res2 = 0 ;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char * kwnames[] = {
29875 (char *) "self",(char *) "other", NULL
29876 };
29877
29878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29882 }
29883 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29885 if (!SWIG_IsOK(res2)) {
29886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29887 }
29888 if (!argp2) {
29889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29890 }
29891 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29906 PyObject *resultobj = 0;
29907 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29908 wxDateSpan *arg2 = 0 ;
29909 wxDateSpan result;
29910 void *argp1 = 0 ;
29911 int res1 = 0 ;
29912 void *argp2 = 0 ;
29913 int res2 = 0 ;
29914 PyObject * obj0 = 0 ;
29915 PyObject * obj1 = 0 ;
29916 char * kwnames[] = {
29917 (char *) "self",(char *) "other", NULL
29918 };
29919
29920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29922 if (!SWIG_IsOK(res1)) {
29923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29924 }
29925 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29927 if (!SWIG_IsOK(res2)) {
29928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29929 }
29930 if (!argp2) {
29931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29932 }
29933 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj = 0;
29949 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29950 int arg2 ;
29951 wxDateSpan result;
29952 void *argp1 = 0 ;
29953 int res1 = 0 ;
29954 int val2 ;
29955 int ecode2 = 0 ;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 char * kwnames[] = {
29959 (char *) "self",(char *) "n", NULL
29960 };
29961
29962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29964 if (!SWIG_IsOK(res1)) {
29965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29966 }
29967 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29968 ecode2 = SWIG_AsVal_int(obj1, &val2);
29969 if (!SWIG_IsOK(ecode2)) {
29970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29971 }
29972 arg2 = static_cast< int >(val2);
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = wxDateSpan___mul__(arg1,arg2);
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29980 return resultobj;
29981 fail:
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj = 0;
29988 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29989 int arg2 ;
29990 wxDateSpan result;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 int val2 ;
29994 int ecode2 = 0 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 char * kwnames[] = {
29998 (char *) "self",(char *) "n", NULL
29999 };
30000
30001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30005 }
30006 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30007 ecode2 = SWIG_AsVal_int(obj1, &val2);
30008 if (!SWIG_IsOK(ecode2)) {
30009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30010 }
30011 arg2 = static_cast< int >(val2);
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 result = wxDateSpan___rmul__(arg1,arg2);
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30026 PyObject *resultobj = 0;
30027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30028 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30029 bool result;
30030 void *argp1 = 0 ;
30031 int res1 = 0 ;
30032 void *argp2 = 0 ;
30033 int res2 = 0 ;
30034 PyObject * obj0 = 0 ;
30035 PyObject * obj1 = 0 ;
30036 char * kwnames[] = {
30037 (char *) "self",(char *) "other", NULL
30038 };
30039
30040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30044 }
30045 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30047 if (!SWIG_IsOK(res2)) {
30048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30049 }
30050 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 {
30058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30059 }
30060 return resultobj;
30061 fail:
30062 return NULL;
30063 }
30064
30065
30066 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30067 PyObject *resultobj = 0;
30068 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30069 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30070 bool result;
30071 void *argp1 = 0 ;
30072 int res1 = 0 ;
30073 void *argp2 = 0 ;
30074 int res2 = 0 ;
30075 PyObject * obj0 = 0 ;
30076 PyObject * obj1 = 0 ;
30077 char * kwnames[] = {
30078 (char *) "self",(char *) "other", NULL
30079 };
30080
30081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30083 if (!SWIG_IsOK(res1)) {
30084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30085 }
30086 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30088 if (!SWIG_IsOK(res2)) {
30089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30090 }
30091 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 {
30099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30100 }
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30108 PyObject *obj;
30109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30110 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30111 return SWIG_Py_Void();
30112 }
30113
30114 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30115 return SWIG_Python_InitShadowInstance(args);
30116 }
30117
30118 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30119 PyObject *resultobj = 0;
30120 long result;
30121
30122 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 result = (long)wxGetLocalTime();
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 resultobj = SWIG_From_long(static_cast< long >(result));
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30137 PyObject *resultobj = 0;
30138 long result;
30139
30140 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = (long)wxGetUTCTime();
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 resultobj = SWIG_From_long(static_cast< long >(result));
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30155 PyObject *resultobj = 0;
30156 long result;
30157
30158 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = (long)wxGetCurrentTime();
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 resultobj = SWIG_From_long(static_cast< long >(result));
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30173 PyObject *resultobj = 0;
30174 wxLongLong result;
30175
30176 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = wxGetLocalTimeMillis();
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 {
30184 PyObject *hi, *lo, *shifter, *shifted;
30185 hi = PyLong_FromLong( (&result)->GetHi() );
30186 lo = PyLong_FromLong( (&result)->GetLo() );
30187 shifter = PyLong_FromLong(32);
30188 shifted = PyNumber_Lshift(hi, shifter);
30189 resultobj = PyNumber_Or(shifted, lo);
30190 Py_DECREF(hi);
30191 Py_DECREF(lo);
30192 Py_DECREF(shifter);
30193 Py_DECREF(shifted);
30194 }
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30202 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30203 return 1;
30204 }
30205
30206
30207 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30208 PyObject *pyobj = 0;
30209
30210 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30211 return pyobj;
30212 }
30213
30214
30215 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30216 PyObject *resultobj = 0;
30217 wxDataFormatId arg1 ;
30218 wxDataFormat *result = 0 ;
30219 int val1 ;
30220 int ecode1 = 0 ;
30221 PyObject * obj0 = 0 ;
30222 char * kwnames[] = {
30223 (char *) "type", NULL
30224 };
30225
30226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30227 ecode1 = SWIG_AsVal_int(obj0, &val1);
30228 if (!SWIG_IsOK(ecode1)) {
30229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30230 }
30231 arg1 = static_cast< wxDataFormatId >(val1);
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = (wxDataFormat *)new wxDataFormat(arg1);
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj = 0;
30247 wxString *arg1 = 0 ;
30248 wxDataFormat *result = 0 ;
30249 bool temp1 = false ;
30250 PyObject * obj0 = 0 ;
30251 char * kwnames[] = {
30252 (char *) "format", NULL
30253 };
30254
30255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30256 {
30257 arg1 = wxString_in_helper(obj0);
30258 if (arg1 == NULL) SWIG_fail;
30259 temp1 = true;
30260 }
30261 {
30262 PyThreadState* __tstate = wxPyBeginAllowThreads();
30263 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30264 wxPyEndAllowThreads(__tstate);
30265 if (PyErr_Occurred()) SWIG_fail;
30266 }
30267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30268 {
30269 if (temp1)
30270 delete arg1;
30271 }
30272 return resultobj;
30273 fail:
30274 {
30275 if (temp1)
30276 delete arg1;
30277 }
30278 return NULL;
30279 }
30280
30281
30282 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30283 PyObject *resultobj = 0;
30284 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30285 void *argp1 = 0 ;
30286 int res1 = 0 ;
30287 PyObject *swig_obj[1] ;
30288
30289 if (!args) SWIG_fail;
30290 swig_obj[0] = args;
30291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30292 if (!SWIG_IsOK(res1)) {
30293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30294 }
30295 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30296 {
30297 PyThreadState* __tstate = wxPyBeginAllowThreads();
30298 delete arg1;
30299
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 resultobj = SWIG_Py_Void();
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30311 PyObject *resultobj = 0;
30312 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30313 wxDataFormatId arg2 ;
30314 bool result;
30315 void *argp1 = 0 ;
30316 int res1 = 0 ;
30317 int val2 ;
30318 int ecode2 = 0 ;
30319
30320 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30322 if (!SWIG_IsOK(res1)) {
30323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30324 }
30325 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30326 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30327 if (!SWIG_IsOK(ecode2)) {
30328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30329 }
30330 arg2 = static_cast< wxDataFormatId >(val2);
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 {
30338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30339 }
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30347 PyObject *resultobj = 0;
30348 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30349 wxDataFormatId arg2 ;
30350 bool result;
30351 void *argp1 = 0 ;
30352 int res1 = 0 ;
30353 int val2 ;
30354 int ecode2 = 0 ;
30355
30356 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30358 if (!SWIG_IsOK(res1)) {
30359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30360 }
30361 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30362 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30363 if (!SWIG_IsOK(ecode2)) {
30364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30365 }
30366 arg2 = static_cast< wxDataFormatId >(val2);
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 {
30374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30375 }
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30383 PyObject *resultobj = 0;
30384 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30385 wxDataFormat *arg2 = 0 ;
30386 bool result;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 void *argp2 = 0 ;
30390 int res2 = 0 ;
30391
30392 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30396 }
30397 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30398 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30399 if (!SWIG_IsOK(res2)) {
30400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30401 }
30402 if (!argp2) {
30403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30404 }
30405 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 {
30413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30414 }
30415 return resultobj;
30416 fail:
30417 return NULL;
30418 }
30419
30420
30421 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30422 int argc;
30423 PyObject *argv[3];
30424
30425 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30426 --argc;
30427 if (argc == 2) {
30428 int _v = 0;
30429 {
30430 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30431 _v = SWIG_CheckState(res);
30432 }
30433 if (!_v) goto check_1;
30434 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30435 }
30436 check_1:
30437
30438 if (argc == 2) {
30439 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30440 }
30441
30442 fail:
30443 Py_INCREF(Py_NotImplemented);
30444 return Py_NotImplemented;
30445 }
30446
30447
30448 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30449 PyObject *resultobj = 0;
30450 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30451 wxDataFormat *arg2 = 0 ;
30452 bool result;
30453 void *argp1 = 0 ;
30454 int res1 = 0 ;
30455 void *argp2 = 0 ;
30456 int res2 = 0 ;
30457
30458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30462 }
30463 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30464 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30465 if (!SWIG_IsOK(res2)) {
30466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30467 }
30468 if (!argp2) {
30469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30470 }
30471 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30488 int argc;
30489 PyObject *argv[3];
30490
30491 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30492 --argc;
30493 if (argc == 2) {
30494 int _v = 0;
30495 {
30496 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30497 _v = SWIG_CheckState(res);
30498 }
30499 if (!_v) goto check_1;
30500 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30501 }
30502 check_1:
30503
30504 if (argc == 2) {
30505 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30506 }
30507
30508 fail:
30509 Py_INCREF(Py_NotImplemented);
30510 return Py_NotImplemented;
30511 }
30512
30513
30514 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj = 0;
30516 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30517 wxDataFormatId arg2 ;
30518 void *argp1 = 0 ;
30519 int res1 = 0 ;
30520 int val2 ;
30521 int ecode2 = 0 ;
30522 PyObject * obj0 = 0 ;
30523 PyObject * obj1 = 0 ;
30524 char * kwnames[] = {
30525 (char *) "self",(char *) "format", NULL
30526 };
30527
30528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30530 if (!SWIG_IsOK(res1)) {
30531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30532 }
30533 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30534 ecode2 = SWIG_AsVal_int(obj1, &val2);
30535 if (!SWIG_IsOK(ecode2)) {
30536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30537 }
30538 arg2 = static_cast< wxDataFormatId >(val2);
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 (arg1)->SetType(arg2);
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 resultobj = SWIG_Py_Void();
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30553 PyObject *resultobj = 0;
30554 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30555 wxDataFormatId result;
30556 void *argp1 = 0 ;
30557 int res1 = 0 ;
30558 PyObject *swig_obj[1] ;
30559
30560 if (!args) SWIG_fail;
30561 swig_obj[0] = args;
30562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30565 }
30566 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_From_int(static_cast< int >(result));
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30581 PyObject *resultobj = 0;
30582 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30583 wxString result;
30584 void *argp1 = 0 ;
30585 int res1 = 0 ;
30586 PyObject *swig_obj[1] ;
30587
30588 if (!args) SWIG_fail;
30589 swig_obj[0] = args;
30590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30591 if (!SWIG_IsOK(res1)) {
30592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30593 }
30594 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30595 {
30596 PyThreadState* __tstate = wxPyBeginAllowThreads();
30597 result = ((wxDataFormat const *)arg1)->GetId();
30598 wxPyEndAllowThreads(__tstate);
30599 if (PyErr_Occurred()) SWIG_fail;
30600 }
30601 {
30602 #if wxUSE_UNICODE
30603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30604 #else
30605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30606 #endif
30607 }
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30615 PyObject *resultobj = 0;
30616 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30617 wxString *arg2 = 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 bool temp2 = false ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "format", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30631 }
30632 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30633 {
30634 arg2 = wxString_in_helper(obj1);
30635 if (arg2 == NULL) SWIG_fail;
30636 temp2 = true;
30637 }
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 (arg1)->SetId((wxString const &)*arg2);
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 resultobj = SWIG_Py_Void();
30645 {
30646 if (temp2)
30647 delete arg2;
30648 }
30649 return resultobj;
30650 fail:
30651 {
30652 if (temp2)
30653 delete arg2;
30654 }
30655 return NULL;
30656 }
30657
30658
30659 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30660 PyObject *obj;
30661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30662 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30663 return SWIG_Py_Void();
30664 }
30665
30666 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30667 return SWIG_Python_InitShadowInstance(args);
30668 }
30669
30670 SWIGINTERN int FormatInvalid_set(PyObject *) {
30671 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30672 return 1;
30673 }
30674
30675
30676 SWIGINTERN PyObject *FormatInvalid_get(void) {
30677 PyObject *pyobj = 0;
30678
30679 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30680 return pyobj;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxDataObject *arg1 = (wxDataObject *) 0 ;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 PyObject *swig_obj[1] ;
30690
30691 if (!args) SWIG_fail;
30692 swig_obj[0] = args;
30693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30696 }
30697 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 delete arg1;
30701
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 resultobj = SWIG_Py_Void();
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj = 0;
30714 wxDataObject *arg1 = (wxDataObject *) 0 ;
30715 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30716 SwigValueWrapper<wxDataFormat > result;
30717 void *argp1 = 0 ;
30718 int res1 = 0 ;
30719 int val2 ;
30720 int ecode2 = 0 ;
30721 PyObject * obj0 = 0 ;
30722 PyObject * obj1 = 0 ;
30723 char * kwnames[] = {
30724 (char *) "self",(char *) "dir", NULL
30725 };
30726
30727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30729 if (!SWIG_IsOK(res1)) {
30730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30731 }
30732 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30733 if (obj1) {
30734 ecode2 = SWIG_AsVal_int(obj1, &val2);
30735 if (!SWIG_IsOK(ecode2)) {
30736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30737 }
30738 arg2 = static_cast< wxDataObject::Direction >(val2);
30739 }
30740 {
30741 PyThreadState* __tstate = wxPyBeginAllowThreads();
30742 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30754 PyObject *resultobj = 0;
30755 wxDataObject *arg1 = (wxDataObject *) 0 ;
30756 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30757 size_t result;
30758 void *argp1 = 0 ;
30759 int res1 = 0 ;
30760 int val2 ;
30761 int ecode2 = 0 ;
30762 PyObject * obj0 = 0 ;
30763 PyObject * obj1 = 0 ;
30764 char * kwnames[] = {
30765 (char *) "self",(char *) "dir", NULL
30766 };
30767
30768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30770 if (!SWIG_IsOK(res1)) {
30771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30772 }
30773 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30774 if (obj1) {
30775 ecode2 = SWIG_AsVal_int(obj1, &val2);
30776 if (!SWIG_IsOK(ecode2)) {
30777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30778 }
30779 arg2 = static_cast< wxDataObject::Direction >(val2);
30780 }
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30795 PyObject *resultobj = 0;
30796 wxDataObject *arg1 = (wxDataObject *) 0 ;
30797 wxDataFormat *arg2 = 0 ;
30798 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30799 bool result;
30800 void *argp1 = 0 ;
30801 int res1 = 0 ;
30802 void *argp2 = 0 ;
30803 int res2 = 0 ;
30804 int val3 ;
30805 int ecode3 = 0 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 PyObject * obj2 = 0 ;
30809 char * kwnames[] = {
30810 (char *) "self",(char *) "format",(char *) "dir", NULL
30811 };
30812
30813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30815 if (!SWIG_IsOK(res1)) {
30816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30817 }
30818 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30820 if (!SWIG_IsOK(res2)) {
30821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30822 }
30823 if (!argp2) {
30824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30825 }
30826 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30827 if (obj2) {
30828 ecode3 = SWIG_AsVal_int(obj2, &val3);
30829 if (!SWIG_IsOK(ecode3)) {
30830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30831 }
30832 arg3 = static_cast< wxDataObject::Direction >(val3);
30833 }
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 {
30841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30850 PyObject *resultobj = 0;
30851 wxDataObject *arg1 = (wxDataObject *) 0 ;
30852 wxDataFormat *arg2 = 0 ;
30853 size_t result;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 void *argp2 = 0 ;
30857 int res2 = 0 ;
30858 PyObject * obj0 = 0 ;
30859 PyObject * obj1 = 0 ;
30860 char * kwnames[] = {
30861 (char *) "self",(char *) "format", NULL
30862 };
30863
30864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30871 if (!SWIG_IsOK(res2)) {
30872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30873 }
30874 if (!argp2) {
30875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30876 }
30877 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj = 0;
30893 wxDataObject *arg1 = (wxDataObject *) 0 ;
30894 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30895 PyObject *result = 0 ;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 int val2 ;
30899 int ecode2 = 0 ;
30900 PyObject * obj0 = 0 ;
30901 PyObject * obj1 = 0 ;
30902 char * kwnames[] = {
30903 (char *) "self",(char *) "dir", NULL
30904 };
30905
30906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30908 if (!SWIG_IsOK(res1)) {
30909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30910 }
30911 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30912 if (obj1) {
30913 ecode2 = SWIG_AsVal_int(obj1, &val2);
30914 if (!SWIG_IsOK(ecode2)) {
30915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30916 }
30917 arg2 = static_cast< wxDataObject::Direction >(val2);
30918 }
30919 {
30920 PyThreadState* __tstate = wxPyBeginAllowThreads();
30921 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30922 wxPyEndAllowThreads(__tstate);
30923 if (PyErr_Occurred()) SWIG_fail;
30924 }
30925 resultobj = result;
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj = 0;
30934 wxDataObject *arg1 = (wxDataObject *) 0 ;
30935 wxDataFormat *arg2 = 0 ;
30936 PyObject *result = 0 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 void *argp2 = 0 ;
30940 int res2 = 0 ;
30941 PyObject * obj0 = 0 ;
30942 PyObject * obj1 = 0 ;
30943 char * kwnames[] = {
30944 (char *) "self",(char *) "format", NULL
30945 };
30946
30947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30951 }
30952 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30954 if (!SWIG_IsOK(res2)) {
30955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30956 }
30957 if (!argp2) {
30958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30959 }
30960 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 resultobj = result;
30968 return resultobj;
30969 fail:
30970 return NULL;
30971 }
30972
30973
30974 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30975 PyObject *resultobj = 0;
30976 wxDataObject *arg1 = (wxDataObject *) 0 ;
30977 wxDataFormat *arg2 = 0 ;
30978 PyObject *arg3 = (PyObject *) 0 ;
30979 bool result;
30980 void *argp1 = 0 ;
30981 int res1 = 0 ;
30982 void *argp2 = 0 ;
30983 int res2 = 0 ;
30984 PyObject * obj0 = 0 ;
30985 PyObject * obj1 = 0 ;
30986 PyObject * obj2 = 0 ;
30987 char * kwnames[] = {
30988 (char *) "self",(char *) "format",(char *) "data", NULL
30989 };
30990
30991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30993 if (!SWIG_IsOK(res1)) {
30994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30995 }
30996 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30998 if (!SWIG_IsOK(res2)) {
30999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31000 }
31001 if (!argp2) {
31002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31003 }
31004 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31005 arg3 = obj2;
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *obj;
31023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31024 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31025 return SWIG_Py_Void();
31026 }
31027
31028 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31029 PyObject *resultobj = 0;
31030 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31031 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31032 wxDataObjectSimple *result = 0 ;
31033 void *argp1 = 0 ;
31034 int res1 = 0 ;
31035 PyObject * obj0 = 0 ;
31036 char * kwnames[] = {
31037 (char *) "format", NULL
31038 };
31039
31040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31041 if (obj0) {
31042 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31043 if (!SWIG_IsOK(res1)) {
31044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31045 }
31046 if (!argp1) {
31047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31048 }
31049 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31050 }
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31058 return resultobj;
31059 fail:
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31065 PyObject *resultobj = 0;
31066 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31067 wxDataFormat *result = 0 ;
31068 void *argp1 = 0 ;
31069 int res1 = 0 ;
31070 PyObject *swig_obj[1] ;
31071
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31077 }
31078 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 {
31082 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31083 result = (wxDataFormat *) &_result_ref;
31084 }
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31096 PyObject *resultobj = 0;
31097 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31098 wxDataFormat *arg2 = 0 ;
31099 void *argp1 = 0 ;
31100 int res1 = 0 ;
31101 void *argp2 = 0 ;
31102 int res2 = 0 ;
31103 PyObject * obj0 = 0 ;
31104 PyObject * obj1 = 0 ;
31105 char * kwnames[] = {
31106 (char *) "self",(char *) "format", NULL
31107 };
31108
31109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31111 if (!SWIG_IsOK(res1)) {
31112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31113 }
31114 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31116 if (!SWIG_IsOK(res2)) {
31117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31118 }
31119 if (!argp2) {
31120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31121 }
31122 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_Py_Void();
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31139 size_t result;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31149 }
31150 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31165 PyObject *resultobj = 0;
31166 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31167 PyObject *result = 0 ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 PyObject *swig_obj[1] ;
31171
31172 if (!args) SWIG_fail;
31173 swig_obj[0] = args;
31174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31177 }
31178 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 resultobj = result;
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj = 0;
31194 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31195 PyObject *arg2 = (PyObject *) 0 ;
31196 bool result;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "data", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31209 }
31210 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31211 arg2 = obj1;
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 {
31219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31220 }
31221 return resultobj;
31222 fail:
31223 return NULL;
31224 }
31225
31226
31227 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31228 PyObject *obj;
31229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31230 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31231 return SWIG_Py_Void();
31232 }
31233
31234 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31235 return SWIG_Python_InitShadowInstance(args);
31236 }
31237
31238 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = 0;
31240 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31241 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31242 wxPyDataObjectSimple *result = 0 ;
31243 void *argp1 = 0 ;
31244 int res1 = 0 ;
31245 PyObject * obj0 = 0 ;
31246 char * kwnames[] = {
31247 (char *) "format", NULL
31248 };
31249
31250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31251 if (obj0) {
31252 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31253 if (!SWIG_IsOK(res1)) {
31254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31255 }
31256 if (!argp1) {
31257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31258 }
31259 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31260 }
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31277 PyObject *arg2 = (PyObject *) 0 ;
31278 PyObject *arg3 = (PyObject *) 0 ;
31279 void *argp1 = 0 ;
31280 int res1 = 0 ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 PyObject * obj2 = 0 ;
31284 char * kwnames[] = {
31285 (char *) "self",(char *) "self",(char *) "_class", NULL
31286 };
31287
31288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31290 if (!SWIG_IsOK(res1)) {
31291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31292 }
31293 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31294 arg2 = obj1;
31295 arg3 = obj2;
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 (arg1)->_setCallbackInfo(arg2,arg3);
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 resultobj = SWIG_Py_Void();
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *obj;
31311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31312 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31313 return SWIG_Py_Void();
31314 }
31315
31316 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31317 return SWIG_Python_InitShadowInstance(args);
31318 }
31319
31320 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321 PyObject *resultobj = 0;
31322 wxDataObjectComposite *result = 0 ;
31323
31324 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31339 PyObject *resultobj = 0;
31340 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31341 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31342 bool arg3 = (bool) false ;
31343 void *argp1 = 0 ;
31344 int res1 = 0 ;
31345 int res2 = 0 ;
31346 bool val3 ;
31347 int ecode3 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 PyObject * obj1 = 0 ;
31350 PyObject * obj2 = 0 ;
31351 char * kwnames[] = {
31352 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31353 };
31354
31355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31357 if (!SWIG_IsOK(res1)) {
31358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31359 }
31360 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31361 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31362 if (!SWIG_IsOK(res2)) {
31363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31364 }
31365 if (obj2) {
31366 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31367 if (!SWIG_IsOK(ecode3)) {
31368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31369 }
31370 arg3 = static_cast< bool >(val3);
31371 }
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 (arg1)->Add(arg2,arg3);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31388 SwigValueWrapper<wxDataFormat > result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31398 }
31399 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *obj;
31415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31416 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31417 return SWIG_Py_Void();
31418 }
31419
31420 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31421 return SWIG_Python_InitShadowInstance(args);
31422 }
31423
31424 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31425 PyObject *resultobj = 0;
31426 wxString const &arg1_defvalue = wxPyEmptyString ;
31427 wxString *arg1 = (wxString *) &arg1_defvalue ;
31428 wxTextDataObject *result = 0 ;
31429 bool temp1 = false ;
31430 PyObject * obj0 = 0 ;
31431 char * kwnames[] = {
31432 (char *) "text", NULL
31433 };
31434
31435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31436 if (obj0) {
31437 {
31438 arg1 = wxString_in_helper(obj0);
31439 if (arg1 == NULL) SWIG_fail;
31440 temp1 = true;
31441 }
31442 }
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31450 {
31451 if (temp1)
31452 delete arg1;
31453 }
31454 return resultobj;
31455 fail:
31456 {
31457 if (temp1)
31458 delete arg1;
31459 }
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31465 PyObject *resultobj = 0;
31466 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31467 size_t result;
31468 void *argp1 = 0 ;
31469 int res1 = 0 ;
31470 PyObject *swig_obj[1] ;
31471
31472 if (!args) SWIG_fail;
31473 swig_obj[0] = args;
31474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31477 }
31478 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 result = (size_t)(arg1)->GetTextLength();
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *resultobj = 0;
31494 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31495 wxString result;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 PyObject *swig_obj[1] ;
31499
31500 if (!args) SWIG_fail;
31501 swig_obj[0] = args;
31502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31503 if (!SWIG_IsOK(res1)) {
31504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31505 }
31506 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (arg1)->GetText();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 {
31514 #if wxUSE_UNICODE
31515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31516 #else
31517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31518 #endif
31519 }
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31527 PyObject *resultobj = 0;
31528 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31529 wxString *arg2 = 0 ;
31530 void *argp1 = 0 ;
31531 int res1 = 0 ;
31532 bool temp2 = false ;
31533 PyObject * obj0 = 0 ;
31534 PyObject * obj1 = 0 ;
31535 char * kwnames[] = {
31536 (char *) "self",(char *) "text", NULL
31537 };
31538
31539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31541 if (!SWIG_IsOK(res1)) {
31542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31543 }
31544 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31545 {
31546 arg2 = wxString_in_helper(obj1);
31547 if (arg2 == NULL) SWIG_fail;
31548 temp2 = true;
31549 }
31550 {
31551 PyThreadState* __tstate = wxPyBeginAllowThreads();
31552 (arg1)->SetText((wxString const &)*arg2);
31553 wxPyEndAllowThreads(__tstate);
31554 if (PyErr_Occurred()) SWIG_fail;
31555 }
31556 resultobj = SWIG_Py_Void();
31557 {
31558 if (temp2)
31559 delete arg2;
31560 }
31561 return resultobj;
31562 fail:
31563 {
31564 if (temp2)
31565 delete arg2;
31566 }
31567 return NULL;
31568 }
31569
31570
31571 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31572 PyObject *obj;
31573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31574 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31575 return SWIG_Py_Void();
31576 }
31577
31578 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31579 return SWIG_Python_InitShadowInstance(args);
31580 }
31581
31582 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj = 0;
31584 wxString const &arg1_defvalue = wxPyEmptyString ;
31585 wxString *arg1 = (wxString *) &arg1_defvalue ;
31586 wxPyTextDataObject *result = 0 ;
31587 bool temp1 = false ;
31588 PyObject * obj0 = 0 ;
31589 char * kwnames[] = {
31590 (char *) "text", NULL
31591 };
31592
31593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31594 if (obj0) {
31595 {
31596 arg1 = wxString_in_helper(obj0);
31597 if (arg1 == NULL) SWIG_fail;
31598 temp1 = true;
31599 }
31600 }
31601 {
31602 PyThreadState* __tstate = wxPyBeginAllowThreads();
31603 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31604 wxPyEndAllowThreads(__tstate);
31605 if (PyErr_Occurred()) SWIG_fail;
31606 }
31607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31608 {
31609 if (temp1)
31610 delete arg1;
31611 }
31612 return resultobj;
31613 fail:
31614 {
31615 if (temp1)
31616 delete arg1;
31617 }
31618 return NULL;
31619 }
31620
31621
31622 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31623 PyObject *resultobj = 0;
31624 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31625 PyObject *arg2 = (PyObject *) 0 ;
31626 PyObject *arg3 = (PyObject *) 0 ;
31627 void *argp1 = 0 ;
31628 int res1 = 0 ;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 PyObject * obj2 = 0 ;
31632 char * kwnames[] = {
31633 (char *) "self",(char *) "self",(char *) "_class", NULL
31634 };
31635
31636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31638 if (!SWIG_IsOK(res1)) {
31639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31640 }
31641 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31642 arg2 = obj1;
31643 arg3 = obj2;
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 (arg1)->_setCallbackInfo(arg2,arg3);
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 resultobj = SWIG_Py_Void();
31651 return resultobj;
31652 fail:
31653 return NULL;
31654 }
31655
31656
31657 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31658 PyObject *obj;
31659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31660 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31661 return SWIG_Py_Void();
31662 }
31663
31664 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31665 return SWIG_Python_InitShadowInstance(args);
31666 }
31667
31668 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31669 PyObject *resultobj = 0;
31670 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31671 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31672 wxBitmapDataObject *result = 0 ;
31673 void *argp1 = 0 ;
31674 int res1 = 0 ;
31675 PyObject * obj0 = 0 ;
31676 char * kwnames[] = {
31677 (char *) "bitmap", NULL
31678 };
31679
31680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31681 if (obj0) {
31682 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31683 if (!SWIG_IsOK(res1)) {
31684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31685 }
31686 if (!argp1) {
31687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31688 }
31689 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31690 }
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31698 return resultobj;
31699 fail:
31700 return NULL;
31701 }
31702
31703
31704 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31705 PyObject *resultobj = 0;
31706 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31707 wxBitmap result;
31708 void *argp1 = 0 ;
31709 int res1 = 0 ;
31710 PyObject *swig_obj[1] ;
31711
31712 if (!args) SWIG_fail;
31713 swig_obj[0] = args;
31714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31717 }
31718 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31733 PyObject *resultobj = 0;
31734 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31735 wxBitmap *arg2 = 0 ;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 void *argp2 = 0 ;
31739 int res2 = 0 ;
31740 PyObject * obj0 = 0 ;
31741 PyObject * obj1 = 0 ;
31742 char * kwnames[] = {
31743 (char *) "self",(char *) "bitmap", NULL
31744 };
31745
31746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31748 if (!SWIG_IsOK(res1)) {
31749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31750 }
31751 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31753 if (!SWIG_IsOK(res2)) {
31754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31755 }
31756 if (!argp2) {
31757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31758 }
31759 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31760 {
31761 PyThreadState* __tstate = wxPyBeginAllowThreads();
31762 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31763 wxPyEndAllowThreads(__tstate);
31764 if (PyErr_Occurred()) SWIG_fail;
31765 }
31766 resultobj = SWIG_Py_Void();
31767 return resultobj;
31768 fail:
31769 return NULL;
31770 }
31771
31772
31773 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 PyObject *obj;
31775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31776 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31777 return SWIG_Py_Void();
31778 }
31779
31780 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31781 return SWIG_Python_InitShadowInstance(args);
31782 }
31783
31784 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31785 PyObject *resultobj = 0;
31786 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31787 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31788 wxPyBitmapDataObject *result = 0 ;
31789 void *argp1 = 0 ;
31790 int res1 = 0 ;
31791 PyObject * obj0 = 0 ;
31792 char * kwnames[] = {
31793 (char *) "bitmap", NULL
31794 };
31795
31796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31797 if (obj0) {
31798 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31801 }
31802 if (!argp1) {
31803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31804 }
31805 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31806 }
31807 {
31808 PyThreadState* __tstate = wxPyBeginAllowThreads();
31809 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31810 wxPyEndAllowThreads(__tstate);
31811 if (PyErr_Occurred()) SWIG_fail;
31812 }
31813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31814 return resultobj;
31815 fail:
31816 return NULL;
31817 }
31818
31819
31820 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31821 PyObject *resultobj = 0;
31822 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31823 PyObject *arg2 = (PyObject *) 0 ;
31824 PyObject *arg3 = (PyObject *) 0 ;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 PyObject * obj0 = 0 ;
31828 PyObject * obj1 = 0 ;
31829 PyObject * obj2 = 0 ;
31830 char * kwnames[] = {
31831 (char *) "self",(char *) "self",(char *) "_class", NULL
31832 };
31833
31834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31836 if (!SWIG_IsOK(res1)) {
31837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31838 }
31839 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31840 arg2 = obj1;
31841 arg3 = obj2;
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 (arg1)->_setCallbackInfo(arg2,arg3);
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_Py_Void();
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31856 PyObject *obj;
31857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31859 return SWIG_Py_Void();
31860 }
31861
31862 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31863 return SWIG_Python_InitShadowInstance(args);
31864 }
31865
31866 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31867 PyObject *resultobj = 0;
31868 wxFileDataObject *result = 0 ;
31869
31870 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31871 {
31872 PyThreadState* __tstate = wxPyBeginAllowThreads();
31873 result = (wxFileDataObject *)new wxFileDataObject();
31874 wxPyEndAllowThreads(__tstate);
31875 if (PyErr_Occurred()) SWIG_fail;
31876 }
31877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31878 return resultobj;
31879 fail:
31880 return NULL;
31881 }
31882
31883
31884 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31885 PyObject *resultobj = 0;
31886 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31887 wxArrayString *result = 0 ;
31888 void *argp1 = 0 ;
31889 int res1 = 0 ;
31890 PyObject *swig_obj[1] ;
31891
31892 if (!args) SWIG_fail;
31893 swig_obj[0] = args;
31894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31895 if (!SWIG_IsOK(res1)) {
31896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31897 }
31898 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31899 {
31900 PyThreadState* __tstate = wxPyBeginAllowThreads();
31901 {
31902 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31903 result = (wxArrayString *) &_result_ref;
31904 }
31905 wxPyEndAllowThreads(__tstate);
31906 if (PyErr_Occurred()) SWIG_fail;
31907 }
31908 {
31909 resultobj = wxArrayString2PyList_helper(*result);
31910 }
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj = 0;
31919 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31920 wxString *arg2 = 0 ;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 bool temp2 = false ;
31924 PyObject * obj0 = 0 ;
31925 PyObject * obj1 = 0 ;
31926 char * kwnames[] = {
31927 (char *) "self",(char *) "filename", NULL
31928 };
31929
31930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31932 if (!SWIG_IsOK(res1)) {
31933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31934 }
31935 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31936 {
31937 arg2 = wxString_in_helper(obj1);
31938 if (arg2 == NULL) SWIG_fail;
31939 temp2 = true;
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->AddFile((wxString const &)*arg2);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 {
31949 if (temp2)
31950 delete arg2;
31951 }
31952 return resultobj;
31953 fail:
31954 {
31955 if (temp2)
31956 delete arg2;
31957 }
31958 return NULL;
31959 }
31960
31961
31962 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 PyObject *obj;
31964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31965 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31966 return SWIG_Py_Void();
31967 }
31968
31969 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31970 return SWIG_Python_InitShadowInstance(args);
31971 }
31972
31973 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31974 PyObject *resultobj = 0;
31975 wxDataFormat *arg1 = 0 ;
31976 wxCustomDataObject *result = 0 ;
31977 void *argp1 = 0 ;
31978 int res1 = 0 ;
31979
31980 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31984 }
31985 if (!argp1) {
31986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31987 }
31988 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31992 wxPyEndAllowThreads(__tstate);
31993 if (PyErr_Occurred()) SWIG_fail;
31994 }
31995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32003 PyObject *resultobj = 0;
32004 wxString *arg1 = 0 ;
32005 wxCustomDataObject *result = 0 ;
32006 bool temp1 = false ;
32007
32008 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32009 {
32010 arg1 = wxString_in_helper(swig_obj[0]);
32011 if (arg1 == NULL) SWIG_fail;
32012 temp1 = true;
32013 }
32014 {
32015 PyThreadState* __tstate = wxPyBeginAllowThreads();
32016 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32017 wxPyEndAllowThreads(__tstate);
32018 if (PyErr_Occurred()) SWIG_fail;
32019 }
32020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32021 {
32022 if (temp1)
32023 delete arg1;
32024 }
32025 return resultobj;
32026 fail:
32027 {
32028 if (temp1)
32029 delete arg1;
32030 }
32031 return NULL;
32032 }
32033
32034
32035 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32036 PyObject *resultobj = 0;
32037 wxCustomDataObject *result = 0 ;
32038
32039 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32040 {
32041 PyThreadState* __tstate = wxPyBeginAllowThreads();
32042 result = (wxCustomDataObject *)new wxCustomDataObject();
32043 wxPyEndAllowThreads(__tstate);
32044 if (PyErr_Occurred()) SWIG_fail;
32045 }
32046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32054 int argc;
32055 PyObject *argv[2];
32056
32057 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32058 --argc;
32059 if (argc == 0) {
32060 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32061 }
32062 if (argc == 1) {
32063 int _v = 0;
32064 {
32065 {
32066 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32067 }
32068 }
32069 if (!_v) goto check_2;
32070 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32071 }
32072 check_2:
32073
32074 if (argc == 1) {
32075 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32076 }
32077
32078 fail:
32079 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32085 PyObject *resultobj = 0;
32086 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32087 PyObject *arg2 = (PyObject *) 0 ;
32088 bool result;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 PyObject * obj0 = 0 ;
32092 PyObject * obj1 = 0 ;
32093 char * kwnames[] = {
32094 (char *) "self",(char *) "data", NULL
32095 };
32096
32097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32101 }
32102 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32103 arg2 = obj1;
32104 {
32105 PyThreadState* __tstate = wxPyBeginAllowThreads();
32106 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32107 wxPyEndAllowThreads(__tstate);
32108 if (PyErr_Occurred()) SWIG_fail;
32109 }
32110 {
32111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32112 }
32113 return resultobj;
32114 fail:
32115 return NULL;
32116 }
32117
32118
32119 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32120 PyObject *resultobj = 0;
32121 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32122 size_t result;
32123 void *argp1 = 0 ;
32124 int res1 = 0 ;
32125 PyObject *swig_obj[1] ;
32126
32127 if (!args) SWIG_fail;
32128 swig_obj[0] = args;
32129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32130 if (!SWIG_IsOK(res1)) {
32131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32132 }
32133 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 result = (size_t)(arg1)->GetSize();
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32141 return resultobj;
32142 fail:
32143 return NULL;
32144 }
32145
32146
32147 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32148 PyObject *resultobj = 0;
32149 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32150 PyObject *result = 0 ;
32151 void *argp1 = 0 ;
32152 int res1 = 0 ;
32153 PyObject *swig_obj[1] ;
32154
32155 if (!args) SWIG_fail;
32156 swig_obj[0] = args;
32157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32158 if (!SWIG_IsOK(res1)) {
32159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32160 }
32161 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = result;
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32176 PyObject *obj;
32177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32178 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32179 return SWIG_Py_Void();
32180 }
32181
32182 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32183 return SWIG_Python_InitShadowInstance(args);
32184 }
32185
32186 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 PyObject *resultobj = 0;
32188 wxURLDataObject *result = 0 ;
32189
32190 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (wxURLDataObject *)new wxURLDataObject();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32207 wxString result;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 PyObject *swig_obj[1] ;
32211
32212 if (!args) SWIG_fail;
32213 swig_obj[0] = args;
32214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32215 if (!SWIG_IsOK(res1)) {
32216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32217 }
32218 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (arg1)->GetURL();
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 {
32226 #if wxUSE_UNICODE
32227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32228 #else
32229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32230 #endif
32231 }
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj = 0;
32240 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32241 wxString *arg2 = 0 ;
32242 void *argp1 = 0 ;
32243 int res1 = 0 ;
32244 bool temp2 = false ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char * kwnames[] = {
32248 (char *) "self",(char *) "url", NULL
32249 };
32250
32251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32253 if (!SWIG_IsOK(res1)) {
32254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32255 }
32256 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32257 {
32258 arg2 = wxString_in_helper(obj1);
32259 if (arg2 == NULL) SWIG_fail;
32260 temp2 = true;
32261 }
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 (arg1)->SetURL((wxString const &)*arg2);
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 resultobj = SWIG_Py_Void();
32269 {
32270 if (temp2)
32271 delete arg2;
32272 }
32273 return resultobj;
32274 fail:
32275 {
32276 if (temp2)
32277 delete arg2;
32278 }
32279 return NULL;
32280 }
32281
32282
32283 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32284 PyObject *obj;
32285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32286 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32287 return SWIG_Py_Void();
32288 }
32289
32290 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 return SWIG_Python_InitShadowInstance(args);
32292 }
32293
32294 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxMetafileDataObject *result = 0 ;
32297
32298 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32299 {
32300 PyThreadState* __tstate = wxPyBeginAllowThreads();
32301 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32302 wxPyEndAllowThreads(__tstate);
32303 if (PyErr_Occurred()) SWIG_fail;
32304 }
32305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32306 return resultobj;
32307 fail:
32308 return NULL;
32309 }
32310
32311
32312 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32313 PyObject *obj;
32314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32315 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32316 return SWIG_Py_Void();
32317 }
32318
32319 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32320 return SWIG_Python_InitShadowInstance(args);
32321 }
32322
32323 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32324 PyObject *resultobj = 0;
32325 wxDragResult arg1 ;
32326 bool result;
32327 int val1 ;
32328 int ecode1 = 0 ;
32329 PyObject * obj0 = 0 ;
32330 char * kwnames[] = {
32331 (char *) "res", NULL
32332 };
32333
32334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32335 ecode1 = SWIG_AsVal_int(obj0, &val1);
32336 if (!SWIG_IsOK(ecode1)) {
32337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32338 }
32339 arg1 = static_cast< wxDragResult >(val1);
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 result = (bool)wxIsDragResultOk(arg1);
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 {
32347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32348 }
32349 return resultobj;
32350 fail:
32351 return NULL;
32352 }
32353
32354
32355 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj = 0;
32357 wxWindow *arg1 = (wxWindow *) 0 ;
32358 wxIcon const &arg2_defvalue = wxNullIcon ;
32359 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32360 wxIcon const &arg3_defvalue = wxNullIcon ;
32361 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32362 wxIcon const &arg4_defvalue = wxNullIcon ;
32363 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32364 wxPyDropSource *result = 0 ;
32365 void *argp1 = 0 ;
32366 int res1 = 0 ;
32367 void *argp2 = 0 ;
32368 int res2 = 0 ;
32369 void *argp3 = 0 ;
32370 int res3 = 0 ;
32371 void *argp4 = 0 ;
32372 int res4 = 0 ;
32373 PyObject * obj0 = 0 ;
32374 PyObject * obj1 = 0 ;
32375 PyObject * obj2 = 0 ;
32376 PyObject * obj3 = 0 ;
32377 char * kwnames[] = {
32378 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32379 };
32380
32381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32383 if (!SWIG_IsOK(res1)) {
32384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32385 }
32386 arg1 = reinterpret_cast< wxWindow * >(argp1);
32387 if (obj1) {
32388 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32389 if (!SWIG_IsOK(res2)) {
32390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32391 }
32392 if (!argp2) {
32393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32394 }
32395 arg2 = reinterpret_cast< wxIcon * >(argp2);
32396 }
32397 if (obj2) {
32398 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32399 if (!SWIG_IsOK(res3)) {
32400 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32401 }
32402 if (!argp3) {
32403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32404 }
32405 arg3 = reinterpret_cast< wxIcon * >(argp3);
32406 }
32407 if (obj3) {
32408 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32409 if (!SWIG_IsOK(res4)) {
32410 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32411 }
32412 if (!argp4) {
32413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32414 }
32415 arg4 = reinterpret_cast< wxIcon * >(argp4);
32416 }
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = 0;
32432 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32433 PyObject *arg2 = (PyObject *) 0 ;
32434 PyObject *arg3 = (PyObject *) 0 ;
32435 int arg4 ;
32436 void *argp1 = 0 ;
32437 int res1 = 0 ;
32438 int val4 ;
32439 int ecode4 = 0 ;
32440 PyObject * obj0 = 0 ;
32441 PyObject * obj1 = 0 ;
32442 PyObject * obj2 = 0 ;
32443 PyObject * obj3 = 0 ;
32444 char * kwnames[] = {
32445 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32446 };
32447
32448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32452 }
32453 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32454 arg2 = obj1;
32455 arg3 = obj2;
32456 ecode4 = SWIG_AsVal_int(obj3, &val4);
32457 if (!SWIG_IsOK(ecode4)) {
32458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32459 }
32460 arg4 = static_cast< int >(val4);
32461 {
32462 PyThreadState* __tstate = wxPyBeginAllowThreads();
32463 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32464 wxPyEndAllowThreads(__tstate);
32465 if (PyErr_Occurred()) SWIG_fail;
32466 }
32467 resultobj = SWIG_Py_Void();
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32475 PyObject *resultobj = 0;
32476 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32477 void *argp1 = 0 ;
32478 int res1 = 0 ;
32479 PyObject *swig_obj[1] ;
32480
32481 if (!args) SWIG_fail;
32482 swig_obj[0] = args;
32483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32486 }
32487 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 delete arg1;
32491
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_Py_Void();
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj = 0;
32504 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32505 wxDataObject *arg2 = 0 ;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 void *argp2 = 0 ;
32509 int res2 = 0 ;
32510 PyObject * obj0 = 0 ;
32511 PyObject * obj1 = 0 ;
32512 char * kwnames[] = {
32513 (char *) "self",(char *) "data", NULL
32514 };
32515
32516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32518 if (!SWIG_IsOK(res1)) {
32519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32520 }
32521 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32523 if (!SWIG_IsOK(res2)) {
32524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32525 }
32526 if (!argp2) {
32527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32528 }
32529 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 (arg1)->SetData(*arg2);
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 resultobj = SWIG_Py_Void();
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32544 PyObject *resultobj = 0;
32545 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32546 wxDataObject *result = 0 ;
32547 void *argp1 = 0 ;
32548 int res1 = 0 ;
32549 PyObject *swig_obj[1] ;
32550
32551 if (!args) SWIG_fail;
32552 swig_obj[0] = args;
32553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32554 if (!SWIG_IsOK(res1)) {
32555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32556 }
32557 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 result = (wxDataObject *)(arg1)->GetDataObject();
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32565 return resultobj;
32566 fail:
32567 return NULL;
32568 }
32569
32570
32571 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32572 PyObject *resultobj = 0;
32573 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32574 wxDragResult arg2 ;
32575 wxCursor *arg3 = 0 ;
32576 void *argp1 = 0 ;
32577 int res1 = 0 ;
32578 int val2 ;
32579 int ecode2 = 0 ;
32580 void *argp3 = 0 ;
32581 int res3 = 0 ;
32582 PyObject * obj0 = 0 ;
32583 PyObject * obj1 = 0 ;
32584 PyObject * obj2 = 0 ;
32585 char * kwnames[] = {
32586 (char *) "self",(char *) "res",(char *) "cursor", NULL
32587 };
32588
32589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32591 if (!SWIG_IsOK(res1)) {
32592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32593 }
32594 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32595 ecode2 = SWIG_AsVal_int(obj1, &val2);
32596 if (!SWIG_IsOK(ecode2)) {
32597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32598 }
32599 arg2 = static_cast< wxDragResult >(val2);
32600 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32601 if (!SWIG_IsOK(res3)) {
32602 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32603 }
32604 if (!argp3) {
32605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32606 }
32607 arg3 = reinterpret_cast< wxCursor * >(argp3);
32608 {
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 resultobj = SWIG_Py_Void();
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = 0;
32623 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32624 int arg2 = (int) wxDrag_CopyOnly ;
32625 wxDragResult result;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 int val2 ;
32629 int ecode2 = 0 ;
32630 PyObject * obj0 = 0 ;
32631 PyObject * obj1 = 0 ;
32632 char * kwnames[] = {
32633 (char *) "self",(char *) "flags", NULL
32634 };
32635
32636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32640 }
32641 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32642 if (obj1) {
32643 ecode2 = SWIG_AsVal_int(obj1, &val2);
32644 if (!SWIG_IsOK(ecode2)) {
32645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32646 }
32647 arg2 = static_cast< int >(val2);
32648 }
32649 {
32650 PyThreadState* __tstate = wxPyBeginAllowThreads();
32651 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 resultobj = SWIG_From_int(static_cast< int >(result));
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32663 PyObject *resultobj = 0;
32664 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32665 wxDragResult arg2 ;
32666 bool result;
32667 void *argp1 = 0 ;
32668 int res1 = 0 ;
32669 int val2 ;
32670 int ecode2 = 0 ;
32671 PyObject * obj0 = 0 ;
32672 PyObject * obj1 = 0 ;
32673 char * kwnames[] = {
32674 (char *) "self",(char *) "effect", NULL
32675 };
32676
32677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32679 if (!SWIG_IsOK(res1)) {
32680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32681 }
32682 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32683 ecode2 = SWIG_AsVal_int(obj1, &val2);
32684 if (!SWIG_IsOK(ecode2)) {
32685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32686 }
32687 arg2 = static_cast< wxDragResult >(val2);
32688 {
32689 PyThreadState* __tstate = wxPyBeginAllowThreads();
32690 result = (bool)(arg1)->GiveFeedback(arg2);
32691 wxPyEndAllowThreads(__tstate);
32692 if (PyErr_Occurred()) SWIG_fail;
32693 }
32694 {
32695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32696 }
32697 return resultobj;
32698 fail:
32699 return NULL;
32700 }
32701
32702
32703 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32704 PyObject *obj;
32705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32706 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32707 return SWIG_Py_Void();
32708 }
32709
32710 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32711 return SWIG_Python_InitShadowInstance(args);
32712 }
32713
32714 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32715 PyObject *resultobj = 0;
32716 wxDataObject *arg1 = (wxDataObject *) NULL ;
32717 wxPyDropTarget *result = 0 ;
32718 int res1 = 0 ;
32719 PyObject * obj0 = 0 ;
32720 char * kwnames[] = {
32721 (char *) "dataObject", NULL
32722 };
32723
32724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32725 if (obj0) {
32726 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32727 if (!SWIG_IsOK(res1)) {
32728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32729 }
32730 }
32731 {
32732 PyThreadState* __tstate = wxPyBeginAllowThreads();
32733 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32734 wxPyEndAllowThreads(__tstate);
32735 if (PyErr_Occurred()) SWIG_fail;
32736 }
32737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32738 return resultobj;
32739 fail:
32740 return NULL;
32741 }
32742
32743
32744 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32745 PyObject *resultobj = 0;
32746 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32747 PyObject *arg2 = (PyObject *) 0 ;
32748 PyObject *arg3 = (PyObject *) 0 ;
32749 void *argp1 = 0 ;
32750 int res1 = 0 ;
32751 PyObject * obj0 = 0 ;
32752 PyObject * obj1 = 0 ;
32753 PyObject * obj2 = 0 ;
32754 char * kwnames[] = {
32755 (char *) "self",(char *) "self",(char *) "_class", NULL
32756 };
32757
32758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32760 if (!SWIG_IsOK(res1)) {
32761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32762 }
32763 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32764 arg2 = obj1;
32765 arg3 = obj2;
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 (arg1)->_setCallbackInfo(arg2,arg3);
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32782 void *argp1 = 0 ;
32783 int res1 = 0 ;
32784 PyObject *swig_obj[1] ;
32785
32786 if (!args) SWIG_fail;
32787 swig_obj[0] = args;
32788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32789 if (!SWIG_IsOK(res1)) {
32790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32791 }
32792 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 delete arg1;
32796
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_Py_Void();
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32808 PyObject *resultobj = 0;
32809 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32810 wxDataObject *result = 0 ;
32811 void *argp1 = 0 ;
32812 int res1 = 0 ;
32813 PyObject *swig_obj[1] ;
32814
32815 if (!args) SWIG_fail;
32816 swig_obj[0] = args;
32817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32818 if (!SWIG_IsOK(res1)) {
32819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32820 }
32821 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32822 {
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (wxDataObject *)(arg1)->GetDataObject();
32825 wxPyEndAllowThreads(__tstate);
32826 if (PyErr_Occurred()) SWIG_fail;
32827 }
32828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj = 0;
32837 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32838 wxDataObject *arg2 = (wxDataObject *) 0 ;
32839 void *argp1 = 0 ;
32840 int res1 = 0 ;
32841 int res2 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 char * kwnames[] = {
32845 (char *) "self",(char *) "dataObject", NULL
32846 };
32847
32848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32852 }
32853 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32854 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32855 if (!SWIG_IsOK(res2)) {
32856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32857 }
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 (arg1)->SetDataObject(arg2);
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 resultobj = SWIG_Py_Void();
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32872 PyObject *resultobj = 0;
32873 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32874 int arg2 ;
32875 int arg3 ;
32876 wxDragResult arg4 ;
32877 wxDragResult result;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 int val2 ;
32881 int ecode2 = 0 ;
32882 int val3 ;
32883 int ecode3 = 0 ;
32884 int val4 ;
32885 int ecode4 = 0 ;
32886 PyObject * obj0 = 0 ;
32887 PyObject * obj1 = 0 ;
32888 PyObject * obj2 = 0 ;
32889 PyObject * obj3 = 0 ;
32890 char * kwnames[] = {
32891 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32892 };
32893
32894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32896 if (!SWIG_IsOK(res1)) {
32897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32898 }
32899 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32900 ecode2 = SWIG_AsVal_int(obj1, &val2);
32901 if (!SWIG_IsOK(ecode2)) {
32902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32903 }
32904 arg2 = static_cast< int >(val2);
32905 ecode3 = SWIG_AsVal_int(obj2, &val3);
32906 if (!SWIG_IsOK(ecode3)) {
32907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32908 }
32909 arg3 = static_cast< int >(val3);
32910 ecode4 = SWIG_AsVal_int(obj3, &val4);
32911 if (!SWIG_IsOK(ecode4)) {
32912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32913 }
32914 arg4 = static_cast< wxDragResult >(val4);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 resultobj = SWIG_From_int(static_cast< int >(result));
32922 return resultobj;
32923 fail:
32924 return NULL;
32925 }
32926
32927
32928 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32929 PyObject *resultobj = 0;
32930 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32931 int arg2 ;
32932 int arg3 ;
32933 wxDragResult arg4 ;
32934 wxDragResult result;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 int val2 ;
32938 int ecode2 = 0 ;
32939 int val3 ;
32940 int ecode3 = 0 ;
32941 int val4 ;
32942 int ecode4 = 0 ;
32943 PyObject * obj0 = 0 ;
32944 PyObject * obj1 = 0 ;
32945 PyObject * obj2 = 0 ;
32946 PyObject * obj3 = 0 ;
32947 char * kwnames[] = {
32948 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32949 };
32950
32951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32953 if (!SWIG_IsOK(res1)) {
32954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32955 }
32956 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32957 ecode2 = SWIG_AsVal_int(obj1, &val2);
32958 if (!SWIG_IsOK(ecode2)) {
32959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32960 }
32961 arg2 = static_cast< int >(val2);
32962 ecode3 = SWIG_AsVal_int(obj2, &val3);
32963 if (!SWIG_IsOK(ecode3)) {
32964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32965 }
32966 arg3 = static_cast< int >(val3);
32967 ecode4 = SWIG_AsVal_int(obj3, &val4);
32968 if (!SWIG_IsOK(ecode4)) {
32969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32970 }
32971 arg4 = static_cast< wxDragResult >(val4);
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 resultobj = SWIG_From_int(static_cast< int >(result));
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32986 PyObject *resultobj = 0;
32987 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32988 void *argp1 = 0 ;
32989 int res1 = 0 ;
32990 PyObject *swig_obj[1] ;
32991
32992 if (!args) SWIG_fail;
32993 swig_obj[0] = args;
32994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32995 if (!SWIG_IsOK(res1)) {
32996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32997 }
32998 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 (arg1)->OnLeave();
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_Py_Void();
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33015 int arg2 ;
33016 int arg3 ;
33017 bool result;
33018 void *argp1 = 0 ;
33019 int res1 = 0 ;
33020 int val2 ;
33021 int ecode2 = 0 ;
33022 int val3 ;
33023 int ecode3 = 0 ;
33024 PyObject * obj0 = 0 ;
33025 PyObject * obj1 = 0 ;
33026 PyObject * obj2 = 0 ;
33027 char * kwnames[] = {
33028 (char *) "self",(char *) "x",(char *) "y", NULL
33029 };
33030
33031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33035 }
33036 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33037 ecode2 = SWIG_AsVal_int(obj1, &val2);
33038 if (!SWIG_IsOK(ecode2)) {
33039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33040 }
33041 arg2 = static_cast< int >(val2);
33042 ecode3 = SWIG_AsVal_int(obj2, &val3);
33043 if (!SWIG_IsOK(ecode3)) {
33044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33045 }
33046 arg3 = static_cast< int >(val3);
33047 {
33048 PyThreadState* __tstate = wxPyBeginAllowThreads();
33049 result = (bool)(arg1)->OnDrop(arg2,arg3);
33050 wxPyEndAllowThreads(__tstate);
33051 if (PyErr_Occurred()) SWIG_fail;
33052 }
33053 {
33054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33055 }
33056 return resultobj;
33057 fail:
33058 return NULL;
33059 }
33060
33061
33062 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33063 PyObject *resultobj = 0;
33064 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33065 bool result;
33066 void *argp1 = 0 ;
33067 int res1 = 0 ;
33068 PyObject *swig_obj[1] ;
33069
33070 if (!args) SWIG_fail;
33071 swig_obj[0] = args;
33072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33073 if (!SWIG_IsOK(res1)) {
33074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33075 }
33076 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (bool)(arg1)->GetData();
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 {
33084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33085 }
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33093 PyObject *resultobj = 0;
33094 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33095 wxDragResult arg2 ;
33096 void *argp1 = 0 ;
33097 int res1 = 0 ;
33098 int val2 ;
33099 int ecode2 = 0 ;
33100 PyObject * obj0 = 0 ;
33101 PyObject * obj1 = 0 ;
33102 char * kwnames[] = {
33103 (char *) "self",(char *) "action", NULL
33104 };
33105
33106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33108 if (!SWIG_IsOK(res1)) {
33109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33110 }
33111 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33112 ecode2 = SWIG_AsVal_int(obj1, &val2);
33113 if (!SWIG_IsOK(ecode2)) {
33114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33115 }
33116 arg2 = static_cast< wxDragResult >(val2);
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 (arg1)->SetDefaultAction(arg2);
33120 wxPyEndAllowThreads(__tstate);
33121 if (PyErr_Occurred()) SWIG_fail;
33122 }
33123 resultobj = SWIG_Py_Void();
33124 return resultobj;
33125 fail:
33126 return NULL;
33127 }
33128
33129
33130 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33131 PyObject *resultobj = 0;
33132 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33133 wxDragResult result;
33134 void *argp1 = 0 ;
33135 int res1 = 0 ;
33136 PyObject *swig_obj[1] ;
33137
33138 if (!args) SWIG_fail;
33139 swig_obj[0] = args;
33140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33143 }
33144 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (wxDragResult)(arg1)->GetDefaultAction();
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 resultobj = SWIG_From_int(static_cast< int >(result));
33152 return resultobj;
33153 fail:
33154 return NULL;
33155 }
33156
33157
33158 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33159 PyObject *obj;
33160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33161 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33162 return SWIG_Py_Void();
33163 }
33164
33165 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33166 return SWIG_Python_InitShadowInstance(args);
33167 }
33168
33169 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33170 PyObject *resultobj = 0;
33171 wxPyTextDropTarget *result = 0 ;
33172
33173 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33174 {
33175 PyThreadState* __tstate = wxPyBeginAllowThreads();
33176 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = 0;
33189 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33190 PyObject *arg2 = (PyObject *) 0 ;
33191 PyObject *arg3 = (PyObject *) 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 PyObject * obj2 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "self",(char *) "_class", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33205 }
33206 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33207 arg2 = obj1;
33208 arg3 = obj2;
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 (arg1)->_setCallbackInfo(arg2,arg3);
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_Py_Void();
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33223 PyObject *resultobj = 0;
33224 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33225 int arg2 ;
33226 int arg3 ;
33227 wxString *arg4 = 0 ;
33228 bool result;
33229 void *argp1 = 0 ;
33230 int res1 = 0 ;
33231 int val2 ;
33232 int ecode2 = 0 ;
33233 int val3 ;
33234 int ecode3 = 0 ;
33235 bool temp4 = false ;
33236 PyObject * obj0 = 0 ;
33237 PyObject * obj1 = 0 ;
33238 PyObject * obj2 = 0 ;
33239 PyObject * obj3 = 0 ;
33240 char * kwnames[] = {
33241 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33242 };
33243
33244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33246 if (!SWIG_IsOK(res1)) {
33247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33248 }
33249 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33250 ecode2 = SWIG_AsVal_int(obj1, &val2);
33251 if (!SWIG_IsOK(ecode2)) {
33252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33253 }
33254 arg2 = static_cast< int >(val2);
33255 ecode3 = SWIG_AsVal_int(obj2, &val3);
33256 if (!SWIG_IsOK(ecode3)) {
33257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33258 }
33259 arg3 = static_cast< int >(val3);
33260 {
33261 arg4 = wxString_in_helper(obj3);
33262 if (arg4 == NULL) SWIG_fail;
33263 temp4 = true;
33264 }
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33273 }
33274 {
33275 if (temp4)
33276 delete arg4;
33277 }
33278 return resultobj;
33279 fail:
33280 {
33281 if (temp4)
33282 delete arg4;
33283 }
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33289 PyObject *resultobj = 0;
33290 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33291 int arg2 ;
33292 int arg3 ;
33293 wxDragResult arg4 ;
33294 wxDragResult result;
33295 void *argp1 = 0 ;
33296 int res1 = 0 ;
33297 int val2 ;
33298 int ecode2 = 0 ;
33299 int val3 ;
33300 int ecode3 = 0 ;
33301 int val4 ;
33302 int ecode4 = 0 ;
33303 PyObject * obj0 = 0 ;
33304 PyObject * obj1 = 0 ;
33305 PyObject * obj2 = 0 ;
33306 PyObject * obj3 = 0 ;
33307 char * kwnames[] = {
33308 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33309 };
33310
33311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33313 if (!SWIG_IsOK(res1)) {
33314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33315 }
33316 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33317 ecode2 = SWIG_AsVal_int(obj1, &val2);
33318 if (!SWIG_IsOK(ecode2)) {
33319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33320 }
33321 arg2 = static_cast< int >(val2);
33322 ecode3 = SWIG_AsVal_int(obj2, &val3);
33323 if (!SWIG_IsOK(ecode3)) {
33324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33325 }
33326 arg3 = static_cast< int >(val3);
33327 ecode4 = SWIG_AsVal_int(obj3, &val4);
33328 if (!SWIG_IsOK(ecode4)) {
33329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33330 }
33331 arg4 = static_cast< wxDragResult >(val4);
33332 {
33333 PyThreadState* __tstate = wxPyBeginAllowThreads();
33334 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33335 wxPyEndAllowThreads(__tstate);
33336 if (PyErr_Occurred()) SWIG_fail;
33337 }
33338 resultobj = SWIG_From_int(static_cast< int >(result));
33339 return resultobj;
33340 fail:
33341 return NULL;
33342 }
33343
33344
33345 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33346 PyObject *resultobj = 0;
33347 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33348 int arg2 ;
33349 int arg3 ;
33350 wxDragResult arg4 ;
33351 wxDragResult result;
33352 void *argp1 = 0 ;
33353 int res1 = 0 ;
33354 int val2 ;
33355 int ecode2 = 0 ;
33356 int val3 ;
33357 int ecode3 = 0 ;
33358 int val4 ;
33359 int ecode4 = 0 ;
33360 PyObject * obj0 = 0 ;
33361 PyObject * obj1 = 0 ;
33362 PyObject * obj2 = 0 ;
33363 PyObject * obj3 = 0 ;
33364 char * kwnames[] = {
33365 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33366 };
33367
33368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33370 if (!SWIG_IsOK(res1)) {
33371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33372 }
33373 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33374 ecode2 = SWIG_AsVal_int(obj1, &val2);
33375 if (!SWIG_IsOK(ecode2)) {
33376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33377 }
33378 arg2 = static_cast< int >(val2);
33379 ecode3 = SWIG_AsVal_int(obj2, &val3);
33380 if (!SWIG_IsOK(ecode3)) {
33381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33382 }
33383 arg3 = static_cast< int >(val3);
33384 ecode4 = SWIG_AsVal_int(obj3, &val4);
33385 if (!SWIG_IsOK(ecode4)) {
33386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33387 }
33388 arg4 = static_cast< wxDragResult >(val4);
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 resultobj = SWIG_From_int(static_cast< int >(result));
33396 return resultobj;
33397 fail:
33398 return NULL;
33399 }
33400
33401
33402 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33403 PyObject *resultobj = 0;
33404 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 PyObject *swig_obj[1] ;
33408
33409 if (!args) SWIG_fail;
33410 swig_obj[0] = args;
33411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33414 }
33415 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33416 {
33417 PyThreadState* __tstate = wxPyBeginAllowThreads();
33418 (arg1)->OnLeave();
33419 wxPyEndAllowThreads(__tstate);
33420 if (PyErr_Occurred()) SWIG_fail;
33421 }
33422 resultobj = SWIG_Py_Void();
33423 return resultobj;
33424 fail:
33425 return NULL;
33426 }
33427
33428
33429 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33430 PyObject *resultobj = 0;
33431 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33432 int arg2 ;
33433 int arg3 ;
33434 bool result;
33435 void *argp1 = 0 ;
33436 int res1 = 0 ;
33437 int val2 ;
33438 int ecode2 = 0 ;
33439 int val3 ;
33440 int ecode3 = 0 ;
33441 PyObject * obj0 = 0 ;
33442 PyObject * obj1 = 0 ;
33443 PyObject * obj2 = 0 ;
33444 char * kwnames[] = {
33445 (char *) "self",(char *) "x",(char *) "y", NULL
33446 };
33447
33448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33450 if (!SWIG_IsOK(res1)) {
33451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33452 }
33453 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33454 ecode2 = SWIG_AsVal_int(obj1, &val2);
33455 if (!SWIG_IsOK(ecode2)) {
33456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33457 }
33458 arg2 = static_cast< int >(val2);
33459 ecode3 = SWIG_AsVal_int(obj2, &val3);
33460 if (!SWIG_IsOK(ecode3)) {
33461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33462 }
33463 arg3 = static_cast< int >(val3);
33464 {
33465 PyThreadState* __tstate = wxPyBeginAllowThreads();
33466 result = (bool)(arg1)->OnDrop(arg2,arg3);
33467 wxPyEndAllowThreads(__tstate);
33468 if (PyErr_Occurred()) SWIG_fail;
33469 }
33470 {
33471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33472 }
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = 0;
33481 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33482 int arg2 ;
33483 int arg3 ;
33484 wxDragResult arg4 ;
33485 wxDragResult result;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 int val2 ;
33489 int ecode2 = 0 ;
33490 int val3 ;
33491 int ecode3 = 0 ;
33492 int val4 ;
33493 int ecode4 = 0 ;
33494 PyObject * obj0 = 0 ;
33495 PyObject * obj1 = 0 ;
33496 PyObject * obj2 = 0 ;
33497 PyObject * obj3 = 0 ;
33498 char * kwnames[] = {
33499 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33500 };
33501
33502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33506 }
33507 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33508 ecode2 = SWIG_AsVal_int(obj1, &val2);
33509 if (!SWIG_IsOK(ecode2)) {
33510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33511 }
33512 arg2 = static_cast< int >(val2);
33513 ecode3 = SWIG_AsVal_int(obj2, &val3);
33514 if (!SWIG_IsOK(ecode3)) {
33515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33516 }
33517 arg3 = static_cast< int >(val3);
33518 ecode4 = SWIG_AsVal_int(obj3, &val4);
33519 if (!SWIG_IsOK(ecode4)) {
33520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33521 }
33522 arg4 = static_cast< wxDragResult >(val4);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 resultobj = SWIG_From_int(static_cast< int >(result));
33530 return resultobj;
33531 fail:
33532 return NULL;
33533 }
33534
33535
33536 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33537 PyObject *obj;
33538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33539 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33540 return SWIG_Py_Void();
33541 }
33542
33543 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33544 return SWIG_Python_InitShadowInstance(args);
33545 }
33546
33547 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 PyObject *resultobj = 0;
33549 wxPyFileDropTarget *result = 0 ;
33550
33551 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33552 {
33553 PyThreadState* __tstate = wxPyBeginAllowThreads();
33554 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33555 wxPyEndAllowThreads(__tstate);
33556 if (PyErr_Occurred()) SWIG_fail;
33557 }
33558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33559 return resultobj;
33560 fail:
33561 return NULL;
33562 }
33563
33564
33565 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33566 PyObject *resultobj = 0;
33567 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33568 PyObject *arg2 = (PyObject *) 0 ;
33569 PyObject *arg3 = (PyObject *) 0 ;
33570 void *argp1 = 0 ;
33571 int res1 = 0 ;
33572 PyObject * obj0 = 0 ;
33573 PyObject * obj1 = 0 ;
33574 PyObject * obj2 = 0 ;
33575 char * kwnames[] = {
33576 (char *) "self",(char *) "self",(char *) "_class", NULL
33577 };
33578
33579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33581 if (!SWIG_IsOK(res1)) {
33582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33583 }
33584 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33585 arg2 = obj1;
33586 arg3 = obj2;
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 (arg1)->_setCallbackInfo(arg2,arg3);
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 resultobj = SWIG_Py_Void();
33594 return resultobj;
33595 fail:
33596 return NULL;
33597 }
33598
33599
33600 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33601 PyObject *resultobj = 0;
33602 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33603 int arg2 ;
33604 int arg3 ;
33605 wxArrayString *arg4 = 0 ;
33606 bool result;
33607 void *argp1 = 0 ;
33608 int res1 = 0 ;
33609 int val2 ;
33610 int ecode2 = 0 ;
33611 int val3 ;
33612 int ecode3 = 0 ;
33613 bool temp4 = false ;
33614 PyObject * obj0 = 0 ;
33615 PyObject * obj1 = 0 ;
33616 PyObject * obj2 = 0 ;
33617 PyObject * obj3 = 0 ;
33618 char * kwnames[] = {
33619 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33620 };
33621
33622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33626 }
33627 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33628 ecode2 = SWIG_AsVal_int(obj1, &val2);
33629 if (!SWIG_IsOK(ecode2)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33631 }
33632 arg2 = static_cast< int >(val2);
33633 ecode3 = SWIG_AsVal_int(obj2, &val3);
33634 if (!SWIG_IsOK(ecode3)) {
33635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33636 }
33637 arg3 = static_cast< int >(val3);
33638 {
33639 if (! PySequence_Check(obj3)) {
33640 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33641 SWIG_fail;
33642 }
33643 arg4 = new wxArrayString;
33644 temp4 = true;
33645 int i, len=PySequence_Length(obj3);
33646 for (i=0; i<len; i++) {
33647 PyObject* item = PySequence_GetItem(obj3, i);
33648 wxString* s = wxString_in_helper(item);
33649 if (PyErr_Occurred()) SWIG_fail;
33650 arg4->Add(*s);
33651 delete s;
33652 Py_DECREF(item);
33653 }
33654 }
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 {
33662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33663 }
33664 {
33665 if (temp4) delete arg4;
33666 }
33667 return resultobj;
33668 fail:
33669 {
33670 if (temp4) delete arg4;
33671 }
33672 return NULL;
33673 }
33674
33675
33676 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33677 PyObject *resultobj = 0;
33678 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33679 int arg2 ;
33680 int arg3 ;
33681 wxDragResult arg4 ;
33682 wxDragResult result;
33683 void *argp1 = 0 ;
33684 int res1 = 0 ;
33685 int val2 ;
33686 int ecode2 = 0 ;
33687 int val3 ;
33688 int ecode3 = 0 ;
33689 int val4 ;
33690 int ecode4 = 0 ;
33691 PyObject * obj0 = 0 ;
33692 PyObject * obj1 = 0 ;
33693 PyObject * obj2 = 0 ;
33694 PyObject * obj3 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33703 }
33704 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33705 ecode2 = SWIG_AsVal_int(obj1, &val2);
33706 if (!SWIG_IsOK(ecode2)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33708 }
33709 arg2 = static_cast< int >(val2);
33710 ecode3 = SWIG_AsVal_int(obj2, &val3);
33711 if (!SWIG_IsOK(ecode3)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33713 }
33714 arg3 = static_cast< int >(val3);
33715 ecode4 = SWIG_AsVal_int(obj3, &val4);
33716 if (!SWIG_IsOK(ecode4)) {
33717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33718 }
33719 arg4 = static_cast< wxDragResult >(val4);
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33723 wxPyEndAllowThreads(__tstate);
33724 if (PyErr_Occurred()) SWIG_fail;
33725 }
33726 resultobj = SWIG_From_int(static_cast< int >(result));
33727 return resultobj;
33728 fail:
33729 return NULL;
33730 }
33731
33732
33733 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33734 PyObject *resultobj = 0;
33735 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33736 int arg2 ;
33737 int arg3 ;
33738 wxDragResult arg4 ;
33739 wxDragResult result;
33740 void *argp1 = 0 ;
33741 int res1 = 0 ;
33742 int val2 ;
33743 int ecode2 = 0 ;
33744 int val3 ;
33745 int ecode3 = 0 ;
33746 int val4 ;
33747 int ecode4 = 0 ;
33748 PyObject * obj0 = 0 ;
33749 PyObject * obj1 = 0 ;
33750 PyObject * obj2 = 0 ;
33751 PyObject * obj3 = 0 ;
33752 char * kwnames[] = {
33753 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33754 };
33755
33756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33760 }
33761 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33762 ecode2 = SWIG_AsVal_int(obj1, &val2);
33763 if (!SWIG_IsOK(ecode2)) {
33764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33765 }
33766 arg2 = static_cast< int >(val2);
33767 ecode3 = SWIG_AsVal_int(obj2, &val3);
33768 if (!SWIG_IsOK(ecode3)) {
33769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33770 }
33771 arg3 = static_cast< int >(val3);
33772 ecode4 = SWIG_AsVal_int(obj3, &val4);
33773 if (!SWIG_IsOK(ecode4)) {
33774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33775 }
33776 arg4 = static_cast< wxDragResult >(val4);
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_From_int(static_cast< int >(result));
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33791 PyObject *resultobj = 0;
33792 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 PyObject *swig_obj[1] ;
33796
33797 if (!args) SWIG_fail;
33798 swig_obj[0] = args;
33799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33802 }
33803 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33804 {
33805 PyThreadState* __tstate = wxPyBeginAllowThreads();
33806 (arg1)->OnLeave();
33807 wxPyEndAllowThreads(__tstate);
33808 if (PyErr_Occurred()) SWIG_fail;
33809 }
33810 resultobj = SWIG_Py_Void();
33811 return resultobj;
33812 fail:
33813 return NULL;
33814 }
33815
33816
33817 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33818 PyObject *resultobj = 0;
33819 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33820 int arg2 ;
33821 int arg3 ;
33822 bool result;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 int val2 ;
33826 int ecode2 = 0 ;
33827 int val3 ;
33828 int ecode3 = 0 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 PyObject * obj2 = 0 ;
33832 char * kwnames[] = {
33833 (char *) "self",(char *) "x",(char *) "y", NULL
33834 };
33835
33836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33838 if (!SWIG_IsOK(res1)) {
33839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33840 }
33841 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33842 ecode2 = SWIG_AsVal_int(obj1, &val2);
33843 if (!SWIG_IsOK(ecode2)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33845 }
33846 arg2 = static_cast< int >(val2);
33847 ecode3 = SWIG_AsVal_int(obj2, &val3);
33848 if (!SWIG_IsOK(ecode3)) {
33849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33850 }
33851 arg3 = static_cast< int >(val3);
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 result = (bool)(arg1)->OnDrop(arg2,arg3);
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 {
33859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33860 }
33861 return resultobj;
33862 fail:
33863 return NULL;
33864 }
33865
33866
33867 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33868 PyObject *resultobj = 0;
33869 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33870 int arg2 ;
33871 int arg3 ;
33872 wxDragResult arg4 ;
33873 wxDragResult result;
33874 void *argp1 = 0 ;
33875 int res1 = 0 ;
33876 int val2 ;
33877 int ecode2 = 0 ;
33878 int val3 ;
33879 int ecode3 = 0 ;
33880 int val4 ;
33881 int ecode4 = 0 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 PyObject * obj2 = 0 ;
33885 PyObject * obj3 = 0 ;
33886 char * kwnames[] = {
33887 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33888 };
33889
33890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33892 if (!SWIG_IsOK(res1)) {
33893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33894 }
33895 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33896 ecode2 = SWIG_AsVal_int(obj1, &val2);
33897 if (!SWIG_IsOK(ecode2)) {
33898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33899 }
33900 arg2 = static_cast< int >(val2);
33901 ecode3 = SWIG_AsVal_int(obj2, &val3);
33902 if (!SWIG_IsOK(ecode3)) {
33903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33904 }
33905 arg3 = static_cast< int >(val3);
33906 ecode4 = SWIG_AsVal_int(obj3, &val4);
33907 if (!SWIG_IsOK(ecode4)) {
33908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33909 }
33910 arg4 = static_cast< wxDragResult >(val4);
33911 {
33912 PyThreadState* __tstate = wxPyBeginAllowThreads();
33913 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33914 wxPyEndAllowThreads(__tstate);
33915 if (PyErr_Occurred()) SWIG_fail;
33916 }
33917 resultobj = SWIG_From_int(static_cast< int >(result));
33918 return resultobj;
33919 fail:
33920 return NULL;
33921 }
33922
33923
33924 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33925 PyObject *obj;
33926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33927 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33928 return SWIG_Py_Void();
33929 }
33930
33931 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33932 return SWIG_Python_InitShadowInstance(args);
33933 }
33934
33935 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33936 PyObject *resultobj = 0;
33937 wxClipboard *result = 0 ;
33938
33939 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33940 {
33941 PyThreadState* __tstate = wxPyBeginAllowThreads();
33942 result = (wxClipboard *)new wxClipboard();
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33947 return resultobj;
33948 fail:
33949 return NULL;
33950 }
33951
33952
33953 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33954 PyObject *resultobj = 0;
33955 wxClipboard *arg1 = (wxClipboard *) 0 ;
33956 void *argp1 = 0 ;
33957 int res1 = 0 ;
33958 PyObject *swig_obj[1] ;
33959
33960 if (!args) SWIG_fail;
33961 swig_obj[0] = args;
33962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33963 if (!SWIG_IsOK(res1)) {
33964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33965 }
33966 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 delete arg1;
33970
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_Py_Void();
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33982 PyObject *resultobj = 0;
33983 wxClipboard *arg1 = (wxClipboard *) 0 ;
33984 bool result;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 PyObject *swig_obj[1] ;
33988
33989 if (!args) SWIG_fail;
33990 swig_obj[0] = args;
33991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33994 }
33995 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (bool)(arg1)->Open();
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 {
34003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34004 }
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34012 PyObject *resultobj = 0;
34013 wxClipboard *arg1 = (wxClipboard *) 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 PyObject *swig_obj[1] ;
34017
34018 if (!args) SWIG_fail;
34019 swig_obj[0] = args;
34020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34023 }
34024 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34025 {
34026 PyThreadState* __tstate = wxPyBeginAllowThreads();
34027 (arg1)->Close();
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 resultobj = SWIG_Py_Void();
34032 return resultobj;
34033 fail:
34034 return NULL;
34035 }
34036
34037
34038 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34039 PyObject *resultobj = 0;
34040 wxClipboard *arg1 = (wxClipboard *) 0 ;
34041 bool result;
34042 void *argp1 = 0 ;
34043 int res1 = 0 ;
34044 PyObject *swig_obj[1] ;
34045
34046 if (!args) SWIG_fail;
34047 swig_obj[0] = args;
34048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34051 }
34052 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34053 {
34054 PyThreadState* __tstate = wxPyBeginAllowThreads();
34055 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 {
34060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34061 }
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj = 0;
34070 wxClipboard *arg1 = (wxClipboard *) 0 ;
34071 wxDataObject *arg2 = (wxDataObject *) 0 ;
34072 bool result;
34073 void *argp1 = 0 ;
34074 int res1 = 0 ;
34075 int res2 = 0 ;
34076 PyObject * obj0 = 0 ;
34077 PyObject * obj1 = 0 ;
34078 char * kwnames[] = {
34079 (char *) "self",(char *) "data", NULL
34080 };
34081
34082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34084 if (!SWIG_IsOK(res1)) {
34085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34086 }
34087 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34088 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34089 if (!SWIG_IsOK(res2)) {
34090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34091 }
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (bool)(arg1)->AddData(arg2);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 {
34099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34100 }
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxClipboard *arg1 = (wxClipboard *) 0 ;
34110 wxDataObject *arg2 = (wxDataObject *) 0 ;
34111 bool result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 int res2 = 0 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "data", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34125 }
34126 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34127 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34128 if (!SWIG_IsOK(res2)) {
34129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34130 }
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 result = (bool)(arg1)->SetData(arg2);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 {
34138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34139 }
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj = 0;
34148 wxClipboard *arg1 = (wxClipboard *) 0 ;
34149 wxDataFormat *arg2 = 0 ;
34150 bool result;
34151 void *argp1 = 0 ;
34152 int res1 = 0 ;
34153 void *argp2 = 0 ;
34154 int res2 = 0 ;
34155 PyObject * obj0 = 0 ;
34156 PyObject * obj1 = 0 ;
34157 char * kwnames[] = {
34158 (char *) "self",(char *) "format", NULL
34159 };
34160
34161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34165 }
34166 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34167 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34168 if (!SWIG_IsOK(res2)) {
34169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34170 }
34171 if (!argp2) {
34172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34173 }
34174 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34175 {
34176 PyThreadState* __tstate = wxPyBeginAllowThreads();
34177 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34178 wxPyEndAllowThreads(__tstate);
34179 if (PyErr_Occurred()) SWIG_fail;
34180 }
34181 {
34182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34183 }
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34191 PyObject *resultobj = 0;
34192 wxClipboard *arg1 = (wxClipboard *) 0 ;
34193 wxDataObject *arg2 = 0 ;
34194 bool result;
34195 void *argp1 = 0 ;
34196 int res1 = 0 ;
34197 void *argp2 = 0 ;
34198 int res2 = 0 ;
34199 PyObject * obj0 = 0 ;
34200 PyObject * obj1 = 0 ;
34201 char * kwnames[] = {
34202 (char *) "self",(char *) "data", NULL
34203 };
34204
34205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34209 }
34210 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34211 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34212 if (!SWIG_IsOK(res2)) {
34213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34214 }
34215 if (!argp2) {
34216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34217 }
34218 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34219 {
34220 PyThreadState* __tstate = wxPyBeginAllowThreads();
34221 result = (bool)(arg1)->GetData(*arg2);
34222 wxPyEndAllowThreads(__tstate);
34223 if (PyErr_Occurred()) SWIG_fail;
34224 }
34225 {
34226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34227 }
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34235 PyObject *resultobj = 0;
34236 wxClipboard *arg1 = (wxClipboard *) 0 ;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 PyObject *swig_obj[1] ;
34240
34241 if (!args) SWIG_fail;
34242 swig_obj[0] = args;
34243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34244 if (!SWIG_IsOK(res1)) {
34245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34246 }
34247 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 (arg1)->Clear();
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 resultobj = SWIG_Py_Void();
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34262 PyObject *resultobj = 0;
34263 wxClipboard *arg1 = (wxClipboard *) 0 ;
34264 bool result;
34265 void *argp1 = 0 ;
34266 int res1 = 0 ;
34267 PyObject *swig_obj[1] ;
34268
34269 if (!args) SWIG_fail;
34270 swig_obj[0] = args;
34271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34272 if (!SWIG_IsOK(res1)) {
34273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34274 }
34275 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 result = (bool)(arg1)->Flush();
34279 wxPyEndAllowThreads(__tstate);
34280 if (PyErr_Occurred()) SWIG_fail;
34281 }
34282 {
34283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34284 }
34285 return resultobj;
34286 fail:
34287 return NULL;
34288 }
34289
34290
34291 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34292 PyObject *resultobj = 0;
34293 wxClipboard *arg1 = (wxClipboard *) 0 ;
34294 bool arg2 = (bool) true ;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 bool val2 ;
34298 int ecode2 = 0 ;
34299 PyObject * obj0 = 0 ;
34300 PyObject * obj1 = 0 ;
34301 char * kwnames[] = {
34302 (char *) "self",(char *) "primary", NULL
34303 };
34304
34305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34307 if (!SWIG_IsOK(res1)) {
34308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34309 }
34310 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34311 if (obj1) {
34312 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34313 if (!SWIG_IsOK(ecode2)) {
34314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34315 }
34316 arg2 = static_cast< bool >(val2);
34317 }
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 (arg1)->UsePrimarySelection(arg2);
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 resultobj = SWIG_Py_Void();
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34332 PyObject *resultobj = 0;
34333 wxClipboard *result = 0 ;
34334
34335 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = (wxClipboard *)wxClipboard::Get();
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34343 return resultobj;
34344 fail:
34345 return NULL;
34346 }
34347
34348
34349 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34350 PyObject *obj;
34351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34352 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34353 return SWIG_Py_Void();
34354 }
34355
34356 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34357 return SWIG_Python_InitShadowInstance(args);
34358 }
34359
34360 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34361 PyObject *resultobj = 0;
34362 wxClipboard *arg1 = (wxClipboard *) NULL ;
34363 wxClipboardLocker *result = 0 ;
34364 void *argp1 = 0 ;
34365 int res1 = 0 ;
34366 PyObject * obj0 = 0 ;
34367 char * kwnames[] = {
34368 (char *) "clipboard", NULL
34369 };
34370
34371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34372 if (obj0) {
34373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34374 if (!SWIG_IsOK(res1)) {
34375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34376 }
34377 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34378 }
34379 {
34380 PyThreadState* __tstate = wxPyBeginAllowThreads();
34381 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34382 wxPyEndAllowThreads(__tstate);
34383 if (PyErr_Occurred()) SWIG_fail;
34384 }
34385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34386 return resultobj;
34387 fail:
34388 return NULL;
34389 }
34390
34391
34392 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34393 PyObject *resultobj = 0;
34394 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 PyObject *swig_obj[1] ;
34398
34399 if (!args) SWIG_fail;
34400 swig_obj[0] = args;
34401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34404 }
34405 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 delete arg1;
34409
34410 wxPyEndAllowThreads(__tstate);
34411 if (PyErr_Occurred()) SWIG_fail;
34412 }
34413 resultobj = SWIG_Py_Void();
34414 return resultobj;
34415 fail:
34416 return NULL;
34417 }
34418
34419
34420 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34421 PyObject *resultobj = 0;
34422 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34423 bool result;
34424 void *argp1 = 0 ;
34425 int res1 = 0 ;
34426 PyObject *swig_obj[1] ;
34427
34428 if (!args) SWIG_fail;
34429 swig_obj[0] = args;
34430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34433 }
34434 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 result = (bool)wxClipboardLocker___nonzero__(arg1);
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 {
34442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34443 }
34444 return resultobj;
34445 fail:
34446 return NULL;
34447 }
34448
34449
34450 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34451 PyObject *obj;
34452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34453 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34454 return SWIG_Py_Void();
34455 }
34456
34457 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 return SWIG_Python_InitShadowInstance(args);
34459 }
34460
34461 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34462 PyObject *resultobj = 0;
34463 int arg1 = (int) 0 ;
34464 int arg2 = (int) 0 ;
34465 int arg3 = (int) 0 ;
34466 int arg4 = (int) 0 ;
34467 wxVideoMode *result = 0 ;
34468 int val1 ;
34469 int ecode1 = 0 ;
34470 int val2 ;
34471 int ecode2 = 0 ;
34472 int val3 ;
34473 int ecode3 = 0 ;
34474 int val4 ;
34475 int ecode4 = 0 ;
34476 PyObject * obj0 = 0 ;
34477 PyObject * obj1 = 0 ;
34478 PyObject * obj2 = 0 ;
34479 PyObject * obj3 = 0 ;
34480 char * kwnames[] = {
34481 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34482 };
34483
34484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34485 if (obj0) {
34486 ecode1 = SWIG_AsVal_int(obj0, &val1);
34487 if (!SWIG_IsOK(ecode1)) {
34488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34489 }
34490 arg1 = static_cast< int >(val1);
34491 }
34492 if (obj1) {
34493 ecode2 = SWIG_AsVal_int(obj1, &val2);
34494 if (!SWIG_IsOK(ecode2)) {
34495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34496 }
34497 arg2 = static_cast< int >(val2);
34498 }
34499 if (obj2) {
34500 ecode3 = SWIG_AsVal_int(obj2, &val3);
34501 if (!SWIG_IsOK(ecode3)) {
34502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34503 }
34504 arg3 = static_cast< int >(val3);
34505 }
34506 if (obj3) {
34507 ecode4 = SWIG_AsVal_int(obj3, &val4);
34508 if (!SWIG_IsOK(ecode4)) {
34509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34510 }
34511 arg4 = static_cast< int >(val4);
34512 }
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34538 }
34539 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 delete arg1;
34543
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 resultobj = SWIG_Py_Void();
34548 return resultobj;
34549 fail:
34550 return NULL;
34551 }
34552
34553
34554 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34555 PyObject *resultobj = 0;
34556 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34557 wxVideoMode *arg2 = 0 ;
34558 bool result;
34559 void *argp1 = 0 ;
34560 int res1 = 0 ;
34561 void *argp2 = 0 ;
34562 int res2 = 0 ;
34563 PyObject * obj0 = 0 ;
34564 PyObject * obj1 = 0 ;
34565 char * kwnames[] = {
34566 (char *) "self",(char *) "other", NULL
34567 };
34568
34569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34571 if (!SWIG_IsOK(res1)) {
34572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34573 }
34574 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34575 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34576 if (!SWIG_IsOK(res2)) {
34577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34578 }
34579 if (!argp2) {
34580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34581 }
34582 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 {
34590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34591 }
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 PyObject *resultobj = 0;
34600 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34601 int result;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 PyObject *swig_obj[1] ;
34605
34606 if (!args) SWIG_fail;
34607 swig_obj[0] = args;
34608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34611 }
34612 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 resultobj = SWIG_From_int(static_cast< int >(result));
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34627 PyObject *resultobj = 0;
34628 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34629 int result;
34630 void *argp1 = 0 ;
34631 int res1 = 0 ;
34632 PyObject *swig_obj[1] ;
34633
34634 if (!args) SWIG_fail;
34635 swig_obj[0] = args;
34636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34637 if (!SWIG_IsOK(res1)) {
34638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34639 }
34640 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34641 {
34642 PyThreadState* __tstate = wxPyBeginAllowThreads();
34643 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34644 wxPyEndAllowThreads(__tstate);
34645 if (PyErr_Occurred()) SWIG_fail;
34646 }
34647 resultobj = SWIG_From_int(static_cast< int >(result));
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34655 PyObject *resultobj = 0;
34656 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34657 int result;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 PyObject *swig_obj[1] ;
34661
34662 if (!args) SWIG_fail;
34663 swig_obj[0] = args;
34664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34665 if (!SWIG_IsOK(res1)) {
34666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34667 }
34668 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 resultobj = SWIG_From_int(static_cast< int >(result));
34676 return resultobj;
34677 fail:
34678 return NULL;
34679 }
34680
34681
34682 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34683 PyObject *resultobj = 0;
34684 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34685 bool result;
34686 void *argp1 = 0 ;
34687 int res1 = 0 ;
34688 PyObject *swig_obj[1] ;
34689
34690 if (!args) SWIG_fail;
34691 swig_obj[0] = args;
34692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34693 if (!SWIG_IsOK(res1)) {
34694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34695 }
34696 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34697 {
34698 PyThreadState* __tstate = wxPyBeginAllowThreads();
34699 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34700 wxPyEndAllowThreads(__tstate);
34701 if (PyErr_Occurred()) SWIG_fail;
34702 }
34703 {
34704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34705 }
34706 return resultobj;
34707 fail:
34708 return NULL;
34709 }
34710
34711
34712 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34713 PyObject *resultobj = 0;
34714 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34715 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34716 bool result;
34717 void *argp1 = 0 ;
34718 int res1 = 0 ;
34719 void *argp2 = 0 ;
34720 int res2 = 0 ;
34721 PyObject * obj0 = 0 ;
34722 PyObject * obj1 = 0 ;
34723 char * kwnames[] = {
34724 (char *) "self",(char *) "other", NULL
34725 };
34726
34727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34729 if (!SWIG_IsOK(res1)) {
34730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34731 }
34732 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34734 if (!SWIG_IsOK(res2)) {
34735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34736 }
34737 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 {
34745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34746 }
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34754 PyObject *resultobj = 0;
34755 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34756 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34757 bool result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 void *argp2 = 0 ;
34761 int res2 = 0 ;
34762 PyObject * obj0 = 0 ;
34763 PyObject * obj1 = 0 ;
34764 char * kwnames[] = {
34765 (char *) "self",(char *) "other", NULL
34766 };
34767
34768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34770 if (!SWIG_IsOK(res1)) {
34771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34772 }
34773 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34775 if (!SWIG_IsOK(res2)) {
34776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34777 }
34778 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 {
34786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34787 }
34788 return resultobj;
34789 fail:
34790 return NULL;
34791 }
34792
34793
34794 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34795 PyObject *resultobj = 0;
34796 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34797 int arg2 ;
34798 void *argp1 = 0 ;
34799 int res1 = 0 ;
34800 int val2 ;
34801 int ecode2 = 0 ;
34802 PyObject *swig_obj[2] ;
34803
34804 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34806 if (!SWIG_IsOK(res1)) {
34807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34808 }
34809 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34811 if (!SWIG_IsOK(ecode2)) {
34812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34813 }
34814 arg2 = static_cast< int >(val2);
34815 if (arg1) (arg1)->w = arg2;
34816
34817 resultobj = SWIG_Py_Void();
34818 return resultobj;
34819 fail:
34820 return NULL;
34821 }
34822
34823
34824 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34825 PyObject *resultobj = 0;
34826 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34827 int result;
34828 void *argp1 = 0 ;
34829 int res1 = 0 ;
34830 PyObject *swig_obj[1] ;
34831
34832 if (!args) SWIG_fail;
34833 swig_obj[0] = args;
34834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34835 if (!SWIG_IsOK(res1)) {
34836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34837 }
34838 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34839 result = (int) ((arg1)->w);
34840 resultobj = SWIG_From_int(static_cast< int >(result));
34841 return resultobj;
34842 fail:
34843 return NULL;
34844 }
34845
34846
34847 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34848 PyObject *resultobj = 0;
34849 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34850 int arg2 ;
34851 void *argp1 = 0 ;
34852 int res1 = 0 ;
34853 int val2 ;
34854 int ecode2 = 0 ;
34855 PyObject *swig_obj[2] ;
34856
34857 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34861 }
34862 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34864 if (!SWIG_IsOK(ecode2)) {
34865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34866 }
34867 arg2 = static_cast< int >(val2);
34868 if (arg1) (arg1)->h = arg2;
34869
34870 resultobj = SWIG_Py_Void();
34871 return resultobj;
34872 fail:
34873 return NULL;
34874 }
34875
34876
34877 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34878 PyObject *resultobj = 0;
34879 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34880 int result;
34881 void *argp1 = 0 ;
34882 int res1 = 0 ;
34883 PyObject *swig_obj[1] ;
34884
34885 if (!args) SWIG_fail;
34886 swig_obj[0] = args;
34887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34888 if (!SWIG_IsOK(res1)) {
34889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34890 }
34891 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34892 result = (int) ((arg1)->h);
34893 resultobj = SWIG_From_int(static_cast< int >(result));
34894 return resultobj;
34895 fail:
34896 return NULL;
34897 }
34898
34899
34900 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34901 PyObject *resultobj = 0;
34902 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34903 int arg2 ;
34904 void *argp1 = 0 ;
34905 int res1 = 0 ;
34906 int val2 ;
34907 int ecode2 = 0 ;
34908 PyObject *swig_obj[2] ;
34909
34910 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34914 }
34915 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34916 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34917 if (!SWIG_IsOK(ecode2)) {
34918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34919 }
34920 arg2 = static_cast< int >(val2);
34921 if (arg1) (arg1)->bpp = arg2;
34922
34923 resultobj = SWIG_Py_Void();
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34931 PyObject *resultobj = 0;
34932 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34933 int result;
34934 void *argp1 = 0 ;
34935 int res1 = 0 ;
34936 PyObject *swig_obj[1] ;
34937
34938 if (!args) SWIG_fail;
34939 swig_obj[0] = args;
34940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34941 if (!SWIG_IsOK(res1)) {
34942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34943 }
34944 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34945 result = (int) ((arg1)->bpp);
34946 resultobj = SWIG_From_int(static_cast< int >(result));
34947 return resultobj;
34948 fail:
34949 return NULL;
34950 }
34951
34952
34953 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34954 PyObject *resultobj = 0;
34955 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34956 int arg2 ;
34957 void *argp1 = 0 ;
34958 int res1 = 0 ;
34959 int val2 ;
34960 int ecode2 = 0 ;
34961 PyObject *swig_obj[2] ;
34962
34963 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34965 if (!SWIG_IsOK(res1)) {
34966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34967 }
34968 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34970 if (!SWIG_IsOK(ecode2)) {
34971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34972 }
34973 arg2 = static_cast< int >(val2);
34974 if (arg1) (arg1)->refresh = arg2;
34975
34976 resultobj = SWIG_Py_Void();
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34984 PyObject *resultobj = 0;
34985 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34986 int result;
34987 void *argp1 = 0 ;
34988 int res1 = 0 ;
34989 PyObject *swig_obj[1] ;
34990
34991 if (!args) SWIG_fail;
34992 swig_obj[0] = args;
34993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34994 if (!SWIG_IsOK(res1)) {
34995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34996 }
34997 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34998 result = (int) ((arg1)->refresh);
34999 resultobj = SWIG_From_int(static_cast< int >(result));
35000 return resultobj;
35001 fail:
35002 return NULL;
35003 }
35004
35005
35006 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35007 PyObject *obj;
35008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35009 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35010 return SWIG_Py_Void();
35011 }
35012
35013 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35014 return SWIG_Python_InitShadowInstance(args);
35015 }
35016
35017 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35018 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35019 return 1;
35020 }
35021
35022
35023 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35024 PyObject *pyobj = 0;
35025
35026 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35027 return pyobj;
35028 }
35029
35030
35031 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35032 PyObject *resultobj = 0;
35033 size_t arg1 = (size_t) 0 ;
35034 wxDisplay *result = 0 ;
35035 size_t val1 ;
35036 int ecode1 = 0 ;
35037 PyObject * obj0 = 0 ;
35038 char * kwnames[] = {
35039 (char *) "index", NULL
35040 };
35041
35042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35043 if (obj0) {
35044 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35045 if (!SWIG_IsOK(ecode1)) {
35046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35047 }
35048 arg1 = static_cast< size_t >(val1);
35049 }
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 result = (wxDisplay *)new wxDisplay(arg1);
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35064 PyObject *resultobj = 0;
35065 wxDisplay *arg1 = (wxDisplay *) 0 ;
35066 void *argp1 = 0 ;
35067 int res1 = 0 ;
35068 PyObject *swig_obj[1] ;
35069
35070 if (!args) SWIG_fail;
35071 swig_obj[0] = args;
35072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35073 if (!SWIG_IsOK(res1)) {
35074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35075 }
35076 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35077 {
35078 PyThreadState* __tstate = wxPyBeginAllowThreads();
35079 delete arg1;
35080
35081 wxPyEndAllowThreads(__tstate);
35082 if (PyErr_Occurred()) SWIG_fail;
35083 }
35084 resultobj = SWIG_Py_Void();
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35092 PyObject *resultobj = 0;
35093 size_t result;
35094
35095 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (size_t)wxDisplay::GetCount();
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxPoint *arg1 = 0 ;
35112 int result;
35113 wxPoint temp1 ;
35114 PyObject * obj0 = 0 ;
35115 char * kwnames[] = {
35116 (char *) "pt", NULL
35117 };
35118
35119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35120 {
35121 arg1 = &temp1;
35122 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35123 }
35124 {
35125 PyThreadState* __tstate = wxPyBeginAllowThreads();
35126 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 resultobj = SWIG_From_int(static_cast< int >(result));
35131 return resultobj;
35132 fail:
35133 return NULL;
35134 }
35135
35136
35137 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35138 PyObject *resultobj = 0;
35139 wxWindow *arg1 = (wxWindow *) 0 ;
35140 int result;
35141 void *argp1 = 0 ;
35142 int res1 = 0 ;
35143 PyObject * obj0 = 0 ;
35144 char * kwnames[] = {
35145 (char *) "window", NULL
35146 };
35147
35148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35150 if (!SWIG_IsOK(res1)) {
35151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35152 }
35153 arg1 = reinterpret_cast< wxWindow * >(argp1);
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 result = (int)wxDisplay::GetFromWindow(arg1);
35157 wxPyEndAllowThreads(__tstate);
35158 if (PyErr_Occurred()) SWIG_fail;
35159 }
35160 resultobj = SWIG_From_int(static_cast< int >(result));
35161 return resultobj;
35162 fail:
35163 return NULL;
35164 }
35165
35166
35167 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35168 PyObject *resultobj = 0;
35169 wxDisplay *arg1 = (wxDisplay *) 0 ;
35170 bool result;
35171 void *argp1 = 0 ;
35172 int res1 = 0 ;
35173 PyObject *swig_obj[1] ;
35174
35175 if (!args) SWIG_fail;
35176 swig_obj[0] = args;
35177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35178 if (!SWIG_IsOK(res1)) {
35179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35180 }
35181 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35182 {
35183 PyThreadState* __tstate = wxPyBeginAllowThreads();
35184 result = (bool)((wxDisplay const *)arg1)->IsOk();
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 {
35189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35190 }
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35198 PyObject *resultobj = 0;
35199 wxDisplay *arg1 = (wxDisplay *) 0 ;
35200 wxRect result;
35201 void *argp1 = 0 ;
35202 int res1 = 0 ;
35203 PyObject *swig_obj[1] ;
35204
35205 if (!args) SWIG_fail;
35206 swig_obj[0] = args;
35207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35210 }
35211 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35212 {
35213 PyThreadState* __tstate = wxPyBeginAllowThreads();
35214 result = ((wxDisplay const *)arg1)->GetGeometry();
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35219 return resultobj;
35220 fail:
35221 return NULL;
35222 }
35223
35224
35225 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35226 PyObject *resultobj = 0;
35227 wxDisplay *arg1 = (wxDisplay *) 0 ;
35228 wxRect result;
35229 void *argp1 = 0 ;
35230 int res1 = 0 ;
35231 PyObject *swig_obj[1] ;
35232
35233 if (!args) SWIG_fail;
35234 swig_obj[0] = args;
35235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35236 if (!SWIG_IsOK(res1)) {
35237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35238 }
35239 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35240 {
35241 PyThreadState* __tstate = wxPyBeginAllowThreads();
35242 result = ((wxDisplay const *)arg1)->GetClientArea();
35243 wxPyEndAllowThreads(__tstate);
35244 if (PyErr_Occurred()) SWIG_fail;
35245 }
35246 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35247 return resultobj;
35248 fail:
35249 return NULL;
35250 }
35251
35252
35253 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35254 PyObject *resultobj = 0;
35255 wxDisplay *arg1 = (wxDisplay *) 0 ;
35256 wxString result;
35257 void *argp1 = 0 ;
35258 int res1 = 0 ;
35259 PyObject *swig_obj[1] ;
35260
35261 if (!args) SWIG_fail;
35262 swig_obj[0] = args;
35263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35264 if (!SWIG_IsOK(res1)) {
35265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35266 }
35267 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35268 {
35269 PyThreadState* __tstate = wxPyBeginAllowThreads();
35270 result = ((wxDisplay const *)arg1)->GetName();
35271 wxPyEndAllowThreads(__tstate);
35272 if (PyErr_Occurred()) SWIG_fail;
35273 }
35274 {
35275 #if wxUSE_UNICODE
35276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35277 #else
35278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35279 #endif
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35288 PyObject *resultobj = 0;
35289 wxDisplay *arg1 = (wxDisplay *) 0 ;
35290 bool result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 PyObject *swig_obj[1] ;
35294
35295 if (!args) SWIG_fail;
35296 swig_obj[0] = args;
35297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35298 if (!SWIG_IsOK(res1)) {
35299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35300 }
35301 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35302 {
35303 PyThreadState* __tstate = wxPyBeginAllowThreads();
35304 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35305 wxPyEndAllowThreads(__tstate);
35306 if (PyErr_Occurred()) SWIG_fail;
35307 }
35308 {
35309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35310 }
35311 return resultobj;
35312 fail:
35313 return NULL;
35314 }
35315
35316
35317 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35318 PyObject *resultobj = 0;
35319 wxDisplay *arg1 = (wxDisplay *) 0 ;
35320 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35321 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35322 PyObject *result = 0 ;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 void *argp2 = 0 ;
35326 int res2 = 0 ;
35327 PyObject * obj0 = 0 ;
35328 PyObject * obj1 = 0 ;
35329 char * kwnames[] = {
35330 (char *) "self",(char *) "mode", NULL
35331 };
35332
35333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35335 if (!SWIG_IsOK(res1)) {
35336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35337 }
35338 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35339 if (obj1) {
35340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35341 if (!SWIG_IsOK(res2)) {
35342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35343 }
35344 if (!argp2) {
35345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35346 }
35347 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35348 }
35349 {
35350 PyThreadState* __tstate = wxPyBeginAllowThreads();
35351 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35352 wxPyEndAllowThreads(__tstate);
35353 if (PyErr_Occurred()) SWIG_fail;
35354 }
35355 resultobj = result;
35356 return resultobj;
35357 fail:
35358 return NULL;
35359 }
35360
35361
35362 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35363 PyObject *resultobj = 0;
35364 wxDisplay *arg1 = (wxDisplay *) 0 ;
35365 wxVideoMode result;
35366 void *argp1 = 0 ;
35367 int res1 = 0 ;
35368 PyObject *swig_obj[1] ;
35369
35370 if (!args) SWIG_fail;
35371 swig_obj[0] = args;
35372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35375 }
35376 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35384 return resultobj;
35385 fail:
35386 return NULL;
35387 }
35388
35389
35390 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj = 0;
35392 wxDisplay *arg1 = (wxDisplay *) 0 ;
35393 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35394 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35395 bool result;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 void *argp2 = 0 ;
35399 int res2 = 0 ;
35400 PyObject * obj0 = 0 ;
35401 PyObject * obj1 = 0 ;
35402 char * kwnames[] = {
35403 (char *) "self",(char *) "mode", NULL
35404 };
35405
35406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35408 if (!SWIG_IsOK(res1)) {
35409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35410 }
35411 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35412 if (obj1) {
35413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35414 if (!SWIG_IsOK(res2)) {
35415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35416 }
35417 if (!argp2) {
35418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35419 }
35420 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35421 }
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 {
35429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35430 }
35431 return resultobj;
35432 fail:
35433 return NULL;
35434 }
35435
35436
35437 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35438 PyObject *resultobj = 0;
35439 wxDisplay *arg1 = (wxDisplay *) 0 ;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35449 }
35450 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 wxDisplay_ResetMode(arg1);
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 resultobj = SWIG_Py_Void();
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35465 PyObject *obj;
35466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35467 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35468 return SWIG_Py_Void();
35469 }
35470
35471 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35472 return SWIG_Python_InitShadowInstance(args);
35473 }
35474
35475 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35476 PyObject *resultobj = 0;
35477 wxStandardPaths *result = 0 ;
35478
35479 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35480 {
35481 PyThreadState* __tstate = wxPyBeginAllowThreads();
35482 result = (wxStandardPaths *)wxStandardPaths_Get();
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35487 return resultobj;
35488 fail:
35489 return NULL;
35490 }
35491
35492
35493 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35494 PyObject *resultobj = 0;
35495 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35496 wxString result;
35497 void *argp1 = 0 ;
35498 int res1 = 0 ;
35499 PyObject *swig_obj[1] ;
35500
35501 if (!args) SWIG_fail;
35502 swig_obj[0] = args;
35503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35504 if (!SWIG_IsOK(res1)) {
35505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35506 }
35507 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35508 {
35509 PyThreadState* __tstate = wxPyBeginAllowThreads();
35510 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 {
35515 #if wxUSE_UNICODE
35516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35517 #else
35518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35519 #endif
35520 }
35521 return resultobj;
35522 fail:
35523 return NULL;
35524 }
35525
35526
35527 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35528 PyObject *resultobj = 0;
35529 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35530 wxString result;
35531 void *argp1 = 0 ;
35532 int res1 = 0 ;
35533 PyObject *swig_obj[1] ;
35534
35535 if (!args) SWIG_fail;
35536 swig_obj[0] = args;
35537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35538 if (!SWIG_IsOK(res1)) {
35539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35540 }
35541 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 #if wxUSE_UNICODE
35550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35551 #else
35552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35553 #endif
35554 }
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35562 PyObject *resultobj = 0;
35563 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35564 wxString result;
35565 void *argp1 = 0 ;
35566 int res1 = 0 ;
35567 PyObject *swig_obj[1] ;
35568
35569 if (!args) SWIG_fail;
35570 swig_obj[0] = args;
35571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35574 }
35575 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 {
35583 #if wxUSE_UNICODE
35584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35585 #else
35586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35587 #endif
35588 }
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35596 PyObject *resultobj = 0;
35597 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35598 wxString result;
35599 void *argp1 = 0 ;
35600 int res1 = 0 ;
35601 PyObject *swig_obj[1] ;
35602
35603 if (!args) SWIG_fail;
35604 swig_obj[0] = args;
35605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35606 if (!SWIG_IsOK(res1)) {
35607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35608 }
35609 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 {
35617 #if wxUSE_UNICODE
35618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35619 #else
35620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35621 #endif
35622 }
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35630 PyObject *resultobj = 0;
35631 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35632 wxString result;
35633 void *argp1 = 0 ;
35634 int res1 = 0 ;
35635 PyObject *swig_obj[1] ;
35636
35637 if (!args) SWIG_fail;
35638 swig_obj[0] = args;
35639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35640 if (!SWIG_IsOK(res1)) {
35641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35642 }
35643 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35647 wxPyEndAllowThreads(__tstate);
35648 if (PyErr_Occurred()) SWIG_fail;
35649 }
35650 {
35651 #if wxUSE_UNICODE
35652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35653 #else
35654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35655 #endif
35656 }
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35664 PyObject *resultobj = 0;
35665 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35666 wxString result;
35667 void *argp1 = 0 ;
35668 int res1 = 0 ;
35669 PyObject *swig_obj[1] ;
35670
35671 if (!args) SWIG_fail;
35672 swig_obj[0] = args;
35673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35674 if (!SWIG_IsOK(res1)) {
35675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35676 }
35677 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 #if wxUSE_UNICODE
35686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35687 #else
35688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35689 #endif
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35698 PyObject *resultobj = 0;
35699 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35700 wxString result;
35701 void *argp1 = 0 ;
35702 int res1 = 0 ;
35703 PyObject *swig_obj[1] ;
35704
35705 if (!args) SWIG_fail;
35706 swig_obj[0] = args;
35707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35708 if (!SWIG_IsOK(res1)) {
35709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35710 }
35711 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35715 wxPyEndAllowThreads(__tstate);
35716 if (PyErr_Occurred()) SWIG_fail;
35717 }
35718 {
35719 #if wxUSE_UNICODE
35720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35721 #else
35722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35723 #endif
35724 }
35725 return resultobj;
35726 fail:
35727 return NULL;
35728 }
35729
35730
35731 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35732 PyObject *resultobj = 0;
35733 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35734 wxString result;
35735 void *argp1 = 0 ;
35736 int res1 = 0 ;
35737 PyObject *swig_obj[1] ;
35738
35739 if (!args) SWIG_fail;
35740 swig_obj[0] = args;
35741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35742 if (!SWIG_IsOK(res1)) {
35743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35744 }
35745 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35746 {
35747 PyThreadState* __tstate = wxPyBeginAllowThreads();
35748 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35749 wxPyEndAllowThreads(__tstate);
35750 if (PyErr_Occurred()) SWIG_fail;
35751 }
35752 {
35753 #if wxUSE_UNICODE
35754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35755 #else
35756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35757 #endif
35758 }
35759 return resultobj;
35760 fail:
35761 return NULL;
35762 }
35763
35764
35765 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35766 PyObject *resultobj = 0;
35767 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35768 wxString *arg2 = 0 ;
35769 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35770 wxString result;
35771 void *argp1 = 0 ;
35772 int res1 = 0 ;
35773 bool temp2 = false ;
35774 int val3 ;
35775 int ecode3 = 0 ;
35776 PyObject * obj0 = 0 ;
35777 PyObject * obj1 = 0 ;
35778 PyObject * obj2 = 0 ;
35779 char * kwnames[] = {
35780 (char *) "self",(char *) "lang",(char *) "category", NULL
35781 };
35782
35783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35787 }
35788 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35789 {
35790 arg2 = wxString_in_helper(obj1);
35791 if (arg2 == NULL) SWIG_fail;
35792 temp2 = true;
35793 }
35794 if (obj2) {
35795 ecode3 = SWIG_AsVal_int(obj2, &val3);
35796 if (!SWIG_IsOK(ecode3)) {
35797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35798 }
35799 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35800 }
35801 {
35802 PyThreadState* __tstate = wxPyBeginAllowThreads();
35803 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35804 wxPyEndAllowThreads(__tstate);
35805 if (PyErr_Occurred()) SWIG_fail;
35806 }
35807 {
35808 #if wxUSE_UNICODE
35809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35810 #else
35811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35812 #endif
35813 }
35814 {
35815 if (temp2)
35816 delete arg2;
35817 }
35818 return resultobj;
35819 fail:
35820 {
35821 if (temp2)
35822 delete arg2;
35823 }
35824 return NULL;
35825 }
35826
35827
35828 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35829 PyObject *resultobj = 0;
35830 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35831 wxString result;
35832 void *argp1 = 0 ;
35833 int res1 = 0 ;
35834 PyObject *swig_obj[1] ;
35835
35836 if (!args) SWIG_fail;
35837 swig_obj[0] = args;
35838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35839 if (!SWIG_IsOK(res1)) {
35840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35841 }
35842 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 {
35850 #if wxUSE_UNICODE
35851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35852 #else
35853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35854 #endif
35855 }
35856 return resultobj;
35857 fail:
35858 return NULL;
35859 }
35860
35861
35862 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35863 PyObject *resultobj = 0;
35864 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35865 wxString *arg2 = 0 ;
35866 void *argp1 = 0 ;
35867 int res1 = 0 ;
35868 bool temp2 = false ;
35869 PyObject * obj0 = 0 ;
35870 PyObject * obj1 = 0 ;
35871 char * kwnames[] = {
35872 (char *) "self",(char *) "prefix", NULL
35873 };
35874
35875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35877 if (!SWIG_IsOK(res1)) {
35878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35879 }
35880 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35881 {
35882 arg2 = wxString_in_helper(obj1);
35883 if (arg2 == NULL) SWIG_fail;
35884 temp2 = true;
35885 }
35886 {
35887 PyThreadState* __tstate = wxPyBeginAllowThreads();
35888 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35889 wxPyEndAllowThreads(__tstate);
35890 if (PyErr_Occurred()) SWIG_fail;
35891 }
35892 resultobj = SWIG_Py_Void();
35893 {
35894 if (temp2)
35895 delete arg2;
35896 }
35897 return resultobj;
35898 fail:
35899 {
35900 if (temp2)
35901 delete arg2;
35902 }
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35908 PyObject *resultobj = 0;
35909 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35910 wxString result;
35911 void *argp1 = 0 ;
35912 int res1 = 0 ;
35913 PyObject *swig_obj[1] ;
35914
35915 if (!args) SWIG_fail;
35916 swig_obj[0] = args;
35917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35918 if (!SWIG_IsOK(res1)) {
35919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35920 }
35921 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35925 wxPyEndAllowThreads(__tstate);
35926 if (PyErr_Occurred()) SWIG_fail;
35927 }
35928 {
35929 #if wxUSE_UNICODE
35930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35931 #else
35932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35933 #endif
35934 }
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35942 PyObject *obj;
35943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35944 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35945 return SWIG_Py_Void();
35946 }
35947
35948 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35949 PyObject *resultobj = 0;
35950 wxEventType arg1 ;
35951 wxPowerEvent *result = 0 ;
35952 int val1 ;
35953 int ecode1 = 0 ;
35954 PyObject * obj0 = 0 ;
35955 char * kwnames[] = {
35956 (char *) "evtType", NULL
35957 };
35958
35959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
35960 ecode1 = SWIG_AsVal_int(obj0, &val1);
35961 if (!SWIG_IsOK(ecode1)) {
35962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
35963 }
35964 arg1 = static_cast< wxEventType >(val1);
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (wxPowerEvent *)new wxPowerEvent(arg1);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35979 PyObject *resultobj = 0;
35980 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
35981 void *argp1 = 0 ;
35982 int res1 = 0 ;
35983 PyObject *swig_obj[1] ;
35984
35985 if (!args) SWIG_fail;
35986 swig_obj[0] = args;
35987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
35990 }
35991 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 (arg1)->Veto();
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_Py_Void();
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36008 bool result;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 PyObject *swig_obj[1] ;
36012
36013 if (!args) SWIG_fail;
36014 swig_obj[0] = args;
36015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36016 if (!SWIG_IsOK(res1)) {
36017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36018 }
36019 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 {
36027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36028 }
36029 return resultobj;
36030 fail:
36031 return NULL;
36032 }
36033
36034
36035 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36036 PyObject *obj;
36037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36038 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36039 return SWIG_Py_Void();
36040 }
36041
36042 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36043 return SWIG_Python_InitShadowInstance(args);
36044 }
36045
36046 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxPowerType result;
36049
36050 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (wxPowerType)wxGetPowerType();
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 resultobj = SWIG_From_int(static_cast< int >(result));
36058 return resultobj;
36059 fail:
36060 return NULL;
36061 }
36062
36063
36064 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36065 PyObject *resultobj = 0;
36066 wxBatteryState result;
36067
36068 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 result = (wxBatteryState)wxGetBatteryState();
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_From_int(static_cast< int >(result));
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 static PyMethodDef SwigMethods[] = {
36083 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36084 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36086 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36087 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36088 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36090 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36091 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36092 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36094 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36095 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36098 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36099 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36100 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36101 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36102 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36103 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36106 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36107 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36109 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36110 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36111 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36112 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36113 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36114 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36115 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36116 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36117 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36118 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36121 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36122 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36123 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36124 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36125 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36126 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36127 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36128 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36129 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36130 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36131 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36132 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36133 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36134 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36135 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36136 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36137 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36138 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36139 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36140 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36141 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36142 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36143 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36144 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36145 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36146 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36147 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36148 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36149 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36150 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36152 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36153 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36154 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36160 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36161 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36162 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36163 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36164 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36165 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36166 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36167 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36168 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36169 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36170 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36171 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36172 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36174 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36178 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36179 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36181 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36182 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36183 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36184 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36185 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36186 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36187 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36188 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36189 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36190 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36191 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36193 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36194 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36195 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36196 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36198 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36199 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36200 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36202 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36203 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36204 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36205 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36206 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36207 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36208 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36209 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36210 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36214 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36216 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36217 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36219 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36220 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36222 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36223 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36224 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36226 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36227 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36228 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36230 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36231 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36232 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36233 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36234 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36235 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36236 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36237 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36238 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36239 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36241 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36244 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36249 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36252 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36253 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36254 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36256 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36257 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36259 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36260 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36261 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36263 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36264 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36265 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36267 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36270 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36271 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36275 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36278 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36280 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36281 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36282 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36283 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36284 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36285 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36286 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36287 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36289 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36290 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36291 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36292 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36293 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36295 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36296 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36297 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36298 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36299 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36302 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36303 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36304 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36306 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36307 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36310 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36314 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36315 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36317 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36318 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36320 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36321 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36322 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36323 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36324 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36325 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36326 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36327 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36328 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36330 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36331 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36332 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36333 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36334 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36335 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36336 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36337 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36338 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36339 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36341 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36342 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36346 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36347 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36348 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36349 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36350 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36351 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36352 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36353 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36354 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36367 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36369 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36370 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36371 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36372 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36373 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36375 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36376 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36383 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36384 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36385 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36386 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36387 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36388 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36389 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36390 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36391 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36392 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36393 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36394 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36396 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36397 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36398 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36399 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36400 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36401 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36402 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36403 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36407 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36408 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36409 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36410 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36411 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36412 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36413 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36414 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36415 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36416 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36418 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36419 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36420 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36421 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36422 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36423 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36424 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36425 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36426 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36427 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36428 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36429 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36430 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36431 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36432 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36433 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36434 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36435 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36436 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36437 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36438 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36439 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36440 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36441 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36442 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36443 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36444 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36445 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36446 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36447 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36448 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36449 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36450 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36451 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36453 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36454 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36455 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36456 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36457 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36463 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36464 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36465 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36469 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36470 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36473 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36476 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36479 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36480 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36481 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36484 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36485 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36488 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36489 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36490 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36491 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36492 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36493 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36494 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36495 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36496 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36497 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36498 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36500 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36501 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36502 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36503 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36504 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36505 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36506 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36512 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36514 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36515 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36517 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36519 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36524 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36528 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36529 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36530 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36531 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36532 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36535 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36540 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36541 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36542 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36543 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36546 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36547 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36549 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36550 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36552 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36563 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36573 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36575 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36577 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36579 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36580 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36584 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36585 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36587 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36588 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36589 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36591 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36592 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36593 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36595 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36596 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36597 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36598 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36601 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36607 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36612 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36616 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36617 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36618 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36619 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36622 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36625 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36626 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36631 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36655 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36656 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36657 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36658 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36659 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36671 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36672 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36677 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36698 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36699 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36700 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36701 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36714 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36715 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36716 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36717 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36718 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36719 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36721 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36723 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36725 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36727 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36729 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36731 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36733 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36737 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36738 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36742 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36753 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36754 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36755 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36759 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36760 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36761 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36762 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36763 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36764 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36766 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36767 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36769 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36771 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36773 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36775 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36777 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36782 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36783 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36784 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36785 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36786 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36789 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36793 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36801 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36802 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36803 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36804 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36805 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36806 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36809 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36810 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36811 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36813 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36814 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36816 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36817 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36818 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36826 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36828 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36830 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36831 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36833 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36834 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36837 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36838 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36839 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36841 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36842 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36843 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36845 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36846 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36848 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36849 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36852 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36853 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36855 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36857 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36858 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36861 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36862 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36863 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36864 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36866 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36867 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36868 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36870 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36871 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36872 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36873 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36874 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36875 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36877 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36878 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36879 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36880 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36881 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36885 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36887 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36891 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36892 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36895 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36896 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36900 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36902 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36903 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36904 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36905 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36906 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36907 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36911 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36912 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36915 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36916 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36917 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36918 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36922 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36925 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36926 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36927 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36928 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36929 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36930 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36931 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36936 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36937 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36939 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36940 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36941 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36943 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36944 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36945 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36946 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36947 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36948 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36950 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36951 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36952 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36953 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36954 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36955 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36956 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36957 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36958 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36959 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36960 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36961 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36962 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36963 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36964 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36965 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36967 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36968 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36969 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36970 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36971 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36972 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36973 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36974 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36975 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36977 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36979 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36980 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36981 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36982 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36983 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36984 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36985 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36986 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36987 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36988 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36989 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36990 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36991 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36992 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36994 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36995 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
36997 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
36998 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
36999 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37000 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37001 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37002 { NULL, NULL, 0, NULL }
37003 };
37004
37005
37006 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37007
37008 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37009 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37010 }
37011 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37012 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37013 }
37014 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37015 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37016 }
37017 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37018 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37019 }
37020 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37021 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37022 }
37023 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37024 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37025 }
37026 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37027 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37028 }
37029 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37030 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37031 }
37032 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37033 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37034 }
37035 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37037 }
37038 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37039 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37040 }
37041 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37042 return (void *)((wxEvent *) ((wxPyEvent *) x));
37043 }
37044 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37045 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37046 }
37047 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37048 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37049 }
37050 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37051 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37052 }
37053 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37054 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37055 }
37056 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37057 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37058 }
37059 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37060 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37061 }
37062 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37063 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37064 }
37065 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37066 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37067 }
37068 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37069 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37070 }
37071 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37072 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37073 }
37074 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37075 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37076 }
37077 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37078 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37079 }
37080 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37081 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37082 }
37083 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37084 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37085 }
37086 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37087 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37088 }
37089 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37090 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37091 }
37092 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37093 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37094 }
37095 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37096 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37097 }
37098 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37099 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37100 }
37101 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37102 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37103 }
37104 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37105 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37106 }
37107 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37108 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37109 }
37110 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37111 return (void *)((wxEvent *) ((wxShowEvent *) x));
37112 }
37113 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37114 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37115 }
37116 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37117 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37118 }
37119 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37120 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37121 }
37122 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37123 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37124 }
37125 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37126 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37127 }
37128 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37129 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37130 }
37131 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37132 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37133 }
37134 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37135 return (void *)((wxConfigBase *) ((wxConfig *) x));
37136 }
37137 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37138 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37139 }
37140 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37141 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37142 }
37143 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37144 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37145 }
37146 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37147 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37148 }
37149 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37150 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37151 }
37152 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37153 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37154 }
37155 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37156 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37157 }
37158 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37159 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37160 }
37161 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37162 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37163 }
37164 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37165 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37166 }
37167 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37168 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37169 }
37170 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37171 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37172 }
37173 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37174 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37175 }
37176 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37177 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37178 }
37179 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37180 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37181 }
37182 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37183 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37184 }
37185 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37186 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37187 }
37188 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37189 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37190 }
37191 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37192 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37193 }
37194 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37195 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37196 }
37197 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37198 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37199 }
37200 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37201 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37202 }
37203 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37204 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37205 }
37206 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37207 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37208 }
37209 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37210 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37211 }
37212 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37213 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37214 }
37215 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37216 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37217 }
37218 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37219 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37220 }
37221 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37222 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37223 }
37224 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37225 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37226 }
37227 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37228 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37229 }
37230 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37231 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37232 }
37233 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37234 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37235 }
37236 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37237 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37238 }
37239 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37240 return (void *)((wxObject *) ((wxSizerItem *) x));
37241 }
37242 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37243 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37244 }
37245 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37246 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37247 }
37248 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37249 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37250 }
37251 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37252 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37253 }
37254 static void *_p_wxSizerTo_p_wxObject(void *x) {
37255 return (void *)((wxObject *) ((wxSizer *) x));
37256 }
37257 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37258 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37259 }
37260 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37261 return (void *)((wxObject *) ((wxFileHistory *) x));
37262 }
37263 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37264 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37265 }
37266 static void *_p_wxEventTo_p_wxObject(void *x) {
37267 return (void *)((wxObject *) ((wxEvent *) x));
37268 }
37269 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37270 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37271 }
37272 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37273 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37274 }
37275 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37276 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37277 }
37278 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37279 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37280 }
37281 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37282 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37283 }
37284 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37285 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37286 }
37287 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37288 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37289 }
37290 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37291 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37292 }
37293 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37294 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37295 }
37296 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37297 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37298 }
37299 static void *_p_wxControlTo_p_wxObject(void *x) {
37300 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37301 }
37302 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37303 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37304 }
37305 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37306 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37307 }
37308 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37309 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37310 }
37311 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37312 return (void *)((wxObject *) ((wxFSFile *) x));
37313 }
37314 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37315 return (void *)((wxObject *) ((wxClipboard *) x));
37316 }
37317 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37318 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37319 }
37320 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37321 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37322 }
37323 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37324 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37325 }
37326 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37327 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37328 }
37329 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37330 return (void *)((wxObject *) ((wxToolTip *) x));
37331 }
37332 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37333 return (void *)((wxObject *) ((wxMenuItem *) x));
37334 }
37335 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37336 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37337 }
37338 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37339 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37340 }
37341 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37342 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37343 }
37344 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37345 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37346 }
37347 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37348 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37349 }
37350 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37351 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37352 }
37353 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37354 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37355 }
37356 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37357 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37358 }
37359 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37360 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37361 }
37362 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37363 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37364 }
37365 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37366 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37367 }
37368 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37369 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37370 }
37371 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37372 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37373 }
37374 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37375 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37376 }
37377 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37378 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37379 }
37380 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37381 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37382 }
37383 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37384 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37385 }
37386 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37387 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37388 }
37389 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37390 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37391 }
37392 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37393 return (void *)((wxObject *) ((wxImageHandler *) x));
37394 }
37395 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37396 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37397 }
37398 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37399 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37400 }
37401 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37402 return (void *)((wxObject *) ((wxEvtHandler *) x));
37403 }
37404 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37405 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37406 }
37407 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37408 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37409 }
37410 static void *_p_wxImageTo_p_wxObject(void *x) {
37411 return (void *)((wxObject *) ((wxImage *) x));
37412 }
37413 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37414 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37415 }
37416 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37417 return (void *)((wxObject *) ((wxSystemOptions *) x));
37418 }
37419 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37420 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37421 }
37422 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37423 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37424 }
37425 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37426 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37427 }
37428 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37429 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37430 }
37431 static void *_p_wxWindowTo_p_wxObject(void *x) {
37432 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37433 }
37434 static void *_p_wxMenuTo_p_wxObject(void *x) {
37435 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37436 }
37437 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37438 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37439 }
37440 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37441 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37442 }
37443 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37444 return (void *)((wxObject *) ((wxFileSystem *) x));
37445 }
37446 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37447 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37448 }
37449 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37450 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37451 }
37452 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37453 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37454 }
37455 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37456 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37457 }
37458 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37459 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37460 }
37461 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37462 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37463 }
37464 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37465 return (void *)((wxObject *) ((wxBusyInfo *) x));
37466 }
37467 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37468 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37469 }
37470 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37471 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37472 }
37473 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37474 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37475 }
37476 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37477 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37478 }
37479 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37480 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37481 }
37482 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37483 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37484 }
37485 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37486 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37487 }
37488 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37489 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37490 }
37491 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37492 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37493 }
37494 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37495 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37496 }
37497 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37498 return (void *)((wxLog *) ((wxLogBuffer *) x));
37499 }
37500 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37501 return (void *)((wxLog *) ((wxLogStderr *) x));
37502 }
37503 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37504 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37505 }
37506 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37507 return (void *)((wxLog *) ((wxLogWindow *) x));
37508 }
37509 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37510 return (void *)((wxLog *) ((wxLogChain *) x));
37511 }
37512 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37513 return (void *)((wxLog *) ((wxLogGui *) x));
37514 }
37515 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37516 return (void *)((wxLog *) ((wxPyLog *) x));
37517 }
37518 static void *_p_wxControlTo_p_wxWindow(void *x) {
37519 return (void *)((wxWindow *) ((wxControl *) x));
37520 }
37521 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37522 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37523 }
37524 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37525 return (void *)((wxWindow *) ((wxMenuBar *) x));
37526 }
37527 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37528 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37529 }
37530 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37531 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37532 }
37533 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37534 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};
37535 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37536 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37537 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37538 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37539 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37540 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37541 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37542 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37543 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37544 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37545 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37546 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37547 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37548 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37549 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37550 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37551 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37552 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37553 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37554 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37555 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37556 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37557 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37558 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37559 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37560 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37561 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37562 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37563 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37564 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37565 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37566 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37567 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37568 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37569 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37570 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37571 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37572 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37573 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37574 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37575 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37576 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37577 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37578 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37579 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37580 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37581 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37582 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37583 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37584 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37585 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37586 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37587 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37588 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37589 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37590 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37591 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37592 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37593 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37594 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37595 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37596 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37597 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37598 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37599 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37600 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37601 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37602 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37603 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37604 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37605 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37606 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37607 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37608 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37609 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37610 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37611 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37612 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37613 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37614 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37616 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37617 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37618 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37619 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37620 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37621 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37630 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37631 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37632 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37633 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37634 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37635 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37636 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37637 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37638 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37639 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37640 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37641 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37642 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37643 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37644 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37645 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37646 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37647 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37667 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37668 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37669 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37670 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37671 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37672 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37673 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37674 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37675 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37676 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37677 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37701 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37702 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37703 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37704
37705 static swig_type_info *swig_type_initial[] = {
37706 &_swigt__p_char,
37707 &_swigt__p_form_ops_t,
37708 &_swigt__p_int,
37709 &_swigt__p_unsigned_char,
37710 &_swigt__p_unsigned_int,
37711 &_swigt__p_unsigned_long,
37712 &_swigt__p_void,
37713 &_swigt__p_wxANIHandler,
37714 &_swigt__p_wxAcceleratorTable,
37715 &_swigt__p_wxActivateEvent,
37716 &_swigt__p_wxArrayString,
37717 &_swigt__p_wxBMPHandler,
37718 &_swigt__p_wxBitmap,
37719 &_swigt__p_wxBitmapDataObject,
37720 &_swigt__p_wxBoxSizer,
37721 &_swigt__p_wxBusyCursor,
37722 &_swigt__p_wxBusyInfo,
37723 &_swigt__p_wxCURHandler,
37724 &_swigt__p_wxCaret,
37725 &_swigt__p_wxChar,
37726 &_swigt__p_wxChildFocusEvent,
37727 &_swigt__p_wxClipboard,
37728 &_swigt__p_wxClipboardLocker,
37729 &_swigt__p_wxClipboardTextEvent,
37730 &_swigt__p_wxCloseEvent,
37731 &_swigt__p_wxColour,
37732 &_swigt__p_wxCommandEvent,
37733 &_swigt__p_wxConfig,
37734 &_swigt__p_wxConfigBase,
37735 &_swigt__p_wxConfigPathChanger,
37736 &_swigt__p_wxContextMenuEvent,
37737 &_swigt__p_wxControl,
37738 &_swigt__p_wxControlWithItems,
37739 &_swigt__p_wxCursor,
37740 &_swigt__p_wxCustomDataObject,
37741 &_swigt__p_wxDC,
37742 &_swigt__p_wxDataFormat,
37743 &_swigt__p_wxDataObject,
37744 &_swigt__p_wxDataObjectComposite,
37745 &_swigt__p_wxDataObjectSimple,
37746 &_swigt__p_wxDateEvent,
37747 &_swigt__p_wxDateSpan,
37748 &_swigt__p_wxDateTime,
37749 &_swigt__p_wxDateTime__TimeZone,
37750 &_swigt__p_wxDisplay,
37751 &_swigt__p_wxDisplayChangedEvent,
37752 &_swigt__p_wxDropFilesEvent,
37753 &_swigt__p_wxDuplexMode,
37754 &_swigt__p_wxEraseEvent,
37755 &_swigt__p_wxEvent,
37756 &_swigt__p_wxEvtHandler,
37757 &_swigt__p_wxFSFile,
37758 &_swigt__p_wxFileConfig,
37759 &_swigt__p_wxFileDataObject,
37760 &_swigt__p_wxFileHistory,
37761 &_swigt__p_wxFileSystem,
37762 &_swigt__p_wxFileType,
37763 &_swigt__p_wxFileTypeInfo,
37764 &_swigt__p_wxFlexGridSizer,
37765 &_swigt__p_wxFocusEvent,
37766 &_swigt__p_wxFont,
37767 &_swigt__p_wxFrame,
37768 &_swigt__p_wxGBSizerItem,
37769 &_swigt__p_wxGIFHandler,
37770 &_swigt__p_wxGridBagSizer,
37771 &_swigt__p_wxGridSizer,
37772 &_swigt__p_wxICOHandler,
37773 &_swigt__p_wxIcon,
37774 &_swigt__p_wxIconizeEvent,
37775 &_swigt__p_wxIdleEvent,
37776 &_swigt__p_wxImage,
37777 &_swigt__p_wxImageHandler,
37778 &_swigt__p_wxIndividualLayoutConstraint,
37779 &_swigt__p_wxInitDialogEvent,
37780 &_swigt__p_wxJPEGHandler,
37781 &_swigt__p_wxJoystick,
37782 &_swigt__p_wxJoystickEvent,
37783 &_swigt__p_wxKeyEvent,
37784 &_swigt__p_wxKillError,
37785 &_swigt__p_wxLayoutConstraints,
37786 &_swigt__p_wxLog,
37787 &_swigt__p_wxLogBuffer,
37788 &_swigt__p_wxLogChain,
37789 &_swigt__p_wxLogGui,
37790 &_swigt__p_wxLogNull,
37791 &_swigt__p_wxLogStderr,
37792 &_swigt__p_wxLogTextCtrl,
37793 &_swigt__p_wxLogWindow,
37794 &_swigt__p_wxMaximizeEvent,
37795 &_swigt__p_wxMemorySize,
37796 &_swigt__p_wxMenu,
37797 &_swigt__p_wxMenuBar,
37798 &_swigt__p_wxMenuEvent,
37799 &_swigt__p_wxMenuItem,
37800 &_swigt__p_wxMetafileDataObject,
37801 &_swigt__p_wxMimeTypesManager,
37802 &_swigt__p_wxMouseCaptureChangedEvent,
37803 &_swigt__p_wxMouseEvent,
37804 &_swigt__p_wxMouseState,
37805 &_swigt__p_wxMoveEvent,
37806 &_swigt__p_wxMutexGuiLocker,
37807 &_swigt__p_wxNavigationKeyEvent,
37808 &_swigt__p_wxNcPaintEvent,
37809 &_swigt__p_wxNotifyEvent,
37810 &_swigt__p_wxObject,
37811 &_swigt__p_wxOutputStream,
37812 &_swigt__p_wxPCXHandler,
37813 &_swigt__p_wxPNGHandler,
37814 &_swigt__p_wxPNMHandler,
37815 &_swigt__p_wxPaintEvent,
37816 &_swigt__p_wxPaletteChangedEvent,
37817 &_swigt__p_wxPaperSize,
37818 &_swigt__p_wxPoint,
37819 &_swigt__p_wxPowerEvent,
37820 &_swigt__p_wxProcessEvent,
37821 &_swigt__p_wxPyApp,
37822 &_swigt__p_wxPyArtProvider,
37823 &_swigt__p_wxPyBitmapDataObject,
37824 &_swigt__p_wxPyCommandEvent,
37825 &_swigt__p_wxPyDataObjectSimple,
37826 &_swigt__p_wxPyDropSource,
37827 &_swigt__p_wxPyDropTarget,
37828 &_swigt__p_wxPyEvent,
37829 &_swigt__p_wxPyFileDropTarget,
37830 &_swigt__p_wxPyImageHandler,
37831 &_swigt__p_wxPyLog,
37832 &_swigt__p_wxPyProcess,
37833 &_swigt__p_wxPySizer,
37834 &_swigt__p_wxPyTextDataObject,
37835 &_swigt__p_wxPyTextDropTarget,
37836 &_swigt__p_wxPyTimer,
37837 &_swigt__p_wxPyTipProvider,
37838 &_swigt__p_wxPyValidator,
37839 &_swigt__p_wxQueryNewPaletteEvent,
37840 &_swigt__p_wxRect,
37841 &_swigt__p_wxScrollEvent,
37842 &_swigt__p_wxScrollWinEvent,
37843 &_swigt__p_wxSetCursorEvent,
37844 &_swigt__p_wxShowEvent,
37845 &_swigt__p_wxSingleInstanceChecker,
37846 &_swigt__p_wxSize,
37847 &_swigt__p_wxSizeEvent,
37848 &_swigt__p_wxSizer,
37849 &_swigt__p_wxSizerItem,
37850 &_swigt__p_wxSound,
37851 &_swigt__p_wxStandardPaths,
37852 &_swigt__p_wxStaticBoxSizer,
37853 &_swigt__p_wxStdDialogButtonSizer,
37854 &_swigt__p_wxStopWatch,
37855 &_swigt__p_wxString,
37856 &_swigt__p_wxSysColourChangedEvent,
37857 &_swigt__p_wxSystemOptions,
37858 &_swigt__p_wxSystemSettings,
37859 &_swigt__p_wxTIFFHandler,
37860 &_swigt__p_wxTextCtrl,
37861 &_swigt__p_wxTextDataObject,
37862 &_swigt__p_wxTimeSpan,
37863 &_swigt__p_wxTimer,
37864 &_swigt__p_wxTimerEvent,
37865 &_swigt__p_wxTimerRunner,
37866 &_swigt__p_wxTipProvider,
37867 &_swigt__p_wxToolTip,
37868 &_swigt__p_wxURLDataObject,
37869 &_swigt__p_wxUpdateUIEvent,
37870 &_swigt__p_wxValidator,
37871 &_swigt__p_wxVideoMode,
37872 &_swigt__p_wxWindow,
37873 &_swigt__p_wxWindowCreateEvent,
37874 &_swigt__p_wxWindowDestroyEvent,
37875 &_swigt__p_wxWindowDisabler,
37876 &_swigt__p_wxXPMHandler,
37877 };
37878
37879 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37880 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37881 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37882 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37883 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37884 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37885 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37886 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37887 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37888 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}};
37889 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37890 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37891 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37892 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37893 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37894 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37895 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37896 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37897 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}};
37898 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37899 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37900 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37901 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37902 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37903 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}};
37904 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37905 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}};
37906 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37907 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37908 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37909 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37910 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37911 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37912 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37913 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37914 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37915 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37916 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37917 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37918 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37919 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37920 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37921 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37922 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37923 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37924 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37925 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37926 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37927 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37928 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37929 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37930 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37931 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37932 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37933 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37934 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37935 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37936 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37937 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37938 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37939 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37940 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37941 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37942 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37943 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37944 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37945 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37946 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37947 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37948 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
37949 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37950 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37951 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37952 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37953 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37954 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37955 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}};
37956 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37957 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37958 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37959 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37960 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37962 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37963 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37964 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37965 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37966 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37967 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}};
37968 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37969 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37970 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37971 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37972 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37973 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37974 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37975 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37978 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37979 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37980 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37981 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37982 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38015 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38016 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38021 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}};
38022 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38024 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38025 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38031 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38032 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38033 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38039 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}};
38040 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38043 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38044 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}};
38045 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38048 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}};
38049 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38050
38051 static swig_cast_info *swig_cast_initial[] = {
38052 _swigc__p_char,
38053 _swigc__p_form_ops_t,
38054 _swigc__p_int,
38055 _swigc__p_unsigned_char,
38056 _swigc__p_unsigned_int,
38057 _swigc__p_unsigned_long,
38058 _swigc__p_void,
38059 _swigc__p_wxANIHandler,
38060 _swigc__p_wxAcceleratorTable,
38061 _swigc__p_wxActivateEvent,
38062 _swigc__p_wxArrayString,
38063 _swigc__p_wxBMPHandler,
38064 _swigc__p_wxBitmap,
38065 _swigc__p_wxBitmapDataObject,
38066 _swigc__p_wxBoxSizer,
38067 _swigc__p_wxBusyCursor,
38068 _swigc__p_wxBusyInfo,
38069 _swigc__p_wxCURHandler,
38070 _swigc__p_wxCaret,
38071 _swigc__p_wxChar,
38072 _swigc__p_wxChildFocusEvent,
38073 _swigc__p_wxClipboard,
38074 _swigc__p_wxClipboardLocker,
38075 _swigc__p_wxClipboardTextEvent,
38076 _swigc__p_wxCloseEvent,
38077 _swigc__p_wxColour,
38078 _swigc__p_wxCommandEvent,
38079 _swigc__p_wxConfig,
38080 _swigc__p_wxConfigBase,
38081 _swigc__p_wxConfigPathChanger,
38082 _swigc__p_wxContextMenuEvent,
38083 _swigc__p_wxControl,
38084 _swigc__p_wxControlWithItems,
38085 _swigc__p_wxCursor,
38086 _swigc__p_wxCustomDataObject,
38087 _swigc__p_wxDC,
38088 _swigc__p_wxDataFormat,
38089 _swigc__p_wxDataObject,
38090 _swigc__p_wxDataObjectComposite,
38091 _swigc__p_wxDataObjectSimple,
38092 _swigc__p_wxDateEvent,
38093 _swigc__p_wxDateSpan,
38094 _swigc__p_wxDateTime,
38095 _swigc__p_wxDateTime__TimeZone,
38096 _swigc__p_wxDisplay,
38097 _swigc__p_wxDisplayChangedEvent,
38098 _swigc__p_wxDropFilesEvent,
38099 _swigc__p_wxDuplexMode,
38100 _swigc__p_wxEraseEvent,
38101 _swigc__p_wxEvent,
38102 _swigc__p_wxEvtHandler,
38103 _swigc__p_wxFSFile,
38104 _swigc__p_wxFileConfig,
38105 _swigc__p_wxFileDataObject,
38106 _swigc__p_wxFileHistory,
38107 _swigc__p_wxFileSystem,
38108 _swigc__p_wxFileType,
38109 _swigc__p_wxFileTypeInfo,
38110 _swigc__p_wxFlexGridSizer,
38111 _swigc__p_wxFocusEvent,
38112 _swigc__p_wxFont,
38113 _swigc__p_wxFrame,
38114 _swigc__p_wxGBSizerItem,
38115 _swigc__p_wxGIFHandler,
38116 _swigc__p_wxGridBagSizer,
38117 _swigc__p_wxGridSizer,
38118 _swigc__p_wxICOHandler,
38119 _swigc__p_wxIcon,
38120 _swigc__p_wxIconizeEvent,
38121 _swigc__p_wxIdleEvent,
38122 _swigc__p_wxImage,
38123 _swigc__p_wxImageHandler,
38124 _swigc__p_wxIndividualLayoutConstraint,
38125 _swigc__p_wxInitDialogEvent,
38126 _swigc__p_wxJPEGHandler,
38127 _swigc__p_wxJoystick,
38128 _swigc__p_wxJoystickEvent,
38129 _swigc__p_wxKeyEvent,
38130 _swigc__p_wxKillError,
38131 _swigc__p_wxLayoutConstraints,
38132 _swigc__p_wxLog,
38133 _swigc__p_wxLogBuffer,
38134 _swigc__p_wxLogChain,
38135 _swigc__p_wxLogGui,
38136 _swigc__p_wxLogNull,
38137 _swigc__p_wxLogStderr,
38138 _swigc__p_wxLogTextCtrl,
38139 _swigc__p_wxLogWindow,
38140 _swigc__p_wxMaximizeEvent,
38141 _swigc__p_wxMemorySize,
38142 _swigc__p_wxMenu,
38143 _swigc__p_wxMenuBar,
38144 _swigc__p_wxMenuEvent,
38145 _swigc__p_wxMenuItem,
38146 _swigc__p_wxMetafileDataObject,
38147 _swigc__p_wxMimeTypesManager,
38148 _swigc__p_wxMouseCaptureChangedEvent,
38149 _swigc__p_wxMouseEvent,
38150 _swigc__p_wxMouseState,
38151 _swigc__p_wxMoveEvent,
38152 _swigc__p_wxMutexGuiLocker,
38153 _swigc__p_wxNavigationKeyEvent,
38154 _swigc__p_wxNcPaintEvent,
38155 _swigc__p_wxNotifyEvent,
38156 _swigc__p_wxObject,
38157 _swigc__p_wxOutputStream,
38158 _swigc__p_wxPCXHandler,
38159 _swigc__p_wxPNGHandler,
38160 _swigc__p_wxPNMHandler,
38161 _swigc__p_wxPaintEvent,
38162 _swigc__p_wxPaletteChangedEvent,
38163 _swigc__p_wxPaperSize,
38164 _swigc__p_wxPoint,
38165 _swigc__p_wxPowerEvent,
38166 _swigc__p_wxProcessEvent,
38167 _swigc__p_wxPyApp,
38168 _swigc__p_wxPyArtProvider,
38169 _swigc__p_wxPyBitmapDataObject,
38170 _swigc__p_wxPyCommandEvent,
38171 _swigc__p_wxPyDataObjectSimple,
38172 _swigc__p_wxPyDropSource,
38173 _swigc__p_wxPyDropTarget,
38174 _swigc__p_wxPyEvent,
38175 _swigc__p_wxPyFileDropTarget,
38176 _swigc__p_wxPyImageHandler,
38177 _swigc__p_wxPyLog,
38178 _swigc__p_wxPyProcess,
38179 _swigc__p_wxPySizer,
38180 _swigc__p_wxPyTextDataObject,
38181 _swigc__p_wxPyTextDropTarget,
38182 _swigc__p_wxPyTimer,
38183 _swigc__p_wxPyTipProvider,
38184 _swigc__p_wxPyValidator,
38185 _swigc__p_wxQueryNewPaletteEvent,
38186 _swigc__p_wxRect,
38187 _swigc__p_wxScrollEvent,
38188 _swigc__p_wxScrollWinEvent,
38189 _swigc__p_wxSetCursorEvent,
38190 _swigc__p_wxShowEvent,
38191 _swigc__p_wxSingleInstanceChecker,
38192 _swigc__p_wxSize,
38193 _swigc__p_wxSizeEvent,
38194 _swigc__p_wxSizer,
38195 _swigc__p_wxSizerItem,
38196 _swigc__p_wxSound,
38197 _swigc__p_wxStandardPaths,
38198 _swigc__p_wxStaticBoxSizer,
38199 _swigc__p_wxStdDialogButtonSizer,
38200 _swigc__p_wxStopWatch,
38201 _swigc__p_wxString,
38202 _swigc__p_wxSysColourChangedEvent,
38203 _swigc__p_wxSystemOptions,
38204 _swigc__p_wxSystemSettings,
38205 _swigc__p_wxTIFFHandler,
38206 _swigc__p_wxTextCtrl,
38207 _swigc__p_wxTextDataObject,
38208 _swigc__p_wxTimeSpan,
38209 _swigc__p_wxTimer,
38210 _swigc__p_wxTimerEvent,
38211 _swigc__p_wxTimerRunner,
38212 _swigc__p_wxTipProvider,
38213 _swigc__p_wxToolTip,
38214 _swigc__p_wxURLDataObject,
38215 _swigc__p_wxUpdateUIEvent,
38216 _swigc__p_wxValidator,
38217 _swigc__p_wxVideoMode,
38218 _swigc__p_wxWindow,
38219 _swigc__p_wxWindowCreateEvent,
38220 _swigc__p_wxWindowDestroyEvent,
38221 _swigc__p_wxWindowDisabler,
38222 _swigc__p_wxXPMHandler,
38223 };
38224
38225
38226 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38227
38228 static swig_const_info swig_const_table[] = {
38229 {0, 0, 0, 0.0, 0, 0}};
38230
38231 #ifdef __cplusplus
38232 }
38233 #endif
38234 /* -----------------------------------------------------------------------------
38235 * Type initialization:
38236 * This problem is tough by the requirement that no dynamic
38237 * memory is used. Also, since swig_type_info structures store pointers to
38238 * swig_cast_info structures and swig_cast_info structures store pointers back
38239 * to swig_type_info structures, we need some lookup code at initialization.
38240 * The idea is that swig generates all the structures that are needed.
38241 * The runtime then collects these partially filled structures.
38242 * The SWIG_InitializeModule function takes these initial arrays out of
38243 * swig_module, and does all the lookup, filling in the swig_module.types
38244 * array with the correct data and linking the correct swig_cast_info
38245 * structures together.
38246 *
38247 * The generated swig_type_info structures are assigned staticly to an initial
38248 * array. We just loop though that array, and handle each type individually.
38249 * First we lookup if this type has been already loaded, and if so, use the
38250 * loaded structure instead of the generated one. Then we have to fill in the
38251 * cast linked list. The cast data is initially stored in something like a
38252 * two-dimensional array. Each row corresponds to a type (there are the same
38253 * number of rows as there are in the swig_type_initial array). Each entry in
38254 * a column is one of the swig_cast_info structures for that type.
38255 * The cast_initial array is actually an array of arrays, because each row has
38256 * a variable number of columns. So to actually build the cast linked list,
38257 * we find the array of casts associated with the type, and loop through it
38258 * adding the casts to the list. The one last trick we need to do is making
38259 * sure the type pointer in the swig_cast_info struct is correct.
38260 *
38261 * First off, we lookup the cast->type name to see if it is already loaded.
38262 * There are three cases to handle:
38263 * 1) If the cast->type has already been loaded AND the type we are adding
38264 * casting info to has not been loaded (it is in this module), THEN we
38265 * replace the cast->type pointer with the type pointer that has already
38266 * been loaded.
38267 * 2) If BOTH types (the one we are adding casting info to, and the
38268 * cast->type) are loaded, THEN the cast info has already been loaded by
38269 * the previous module so we just ignore it.
38270 * 3) Finally, if cast->type has not already been loaded, then we add that
38271 * swig_cast_info to the linked list (because the cast->type) pointer will
38272 * be correct.
38273 * ----------------------------------------------------------------------------- */
38274
38275 #ifdef __cplusplus
38276 extern "C" {
38277 #if 0
38278 } /* c-mode */
38279 #endif
38280 #endif
38281
38282 #if 0
38283 #define SWIGRUNTIME_DEBUG
38284 #endif
38285
38286 SWIGRUNTIME void
38287 SWIG_InitializeModule(void *clientdata) {
38288 size_t i;
38289 swig_module_info *module_head;
38290 static int init_run = 0;
38291
38292 clientdata = clientdata;
38293
38294 if (init_run) return;
38295 init_run = 1;
38296
38297 /* Initialize the swig_module */
38298 swig_module.type_initial = swig_type_initial;
38299 swig_module.cast_initial = swig_cast_initial;
38300
38301 /* Try and load any already created modules */
38302 module_head = SWIG_GetModule(clientdata);
38303 if (module_head) {
38304 swig_module.next = module_head->next;
38305 module_head->next = &swig_module;
38306 } else {
38307 /* This is the first module loaded */
38308 swig_module.next = &swig_module;
38309 SWIG_SetModule(clientdata, &swig_module);
38310 }
38311
38312 /* Now work on filling in swig_module.types */
38313 #ifdef SWIGRUNTIME_DEBUG
38314 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38315 #endif
38316 for (i = 0; i < swig_module.size; ++i) {
38317 swig_type_info *type = 0;
38318 swig_type_info *ret;
38319 swig_cast_info *cast;
38320
38321 #ifdef SWIGRUNTIME_DEBUG
38322 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38323 #endif
38324
38325 /* if there is another module already loaded */
38326 if (swig_module.next != &swig_module) {
38327 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38328 }
38329 if (type) {
38330 /* Overwrite clientdata field */
38331 #ifdef SWIGRUNTIME_DEBUG
38332 printf("SWIG_InitializeModule: found type %s\n", type->name);
38333 #endif
38334 if (swig_module.type_initial[i]->clientdata) {
38335 type->clientdata = swig_module.type_initial[i]->clientdata;
38336 #ifdef SWIGRUNTIME_DEBUG
38337 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38338 #endif
38339 }
38340 } else {
38341 type = swig_module.type_initial[i];
38342 }
38343
38344 /* Insert casting types */
38345 cast = swig_module.cast_initial[i];
38346 while (cast->type) {
38347 /* Don't need to add information already in the list */
38348 ret = 0;
38349 #ifdef SWIGRUNTIME_DEBUG
38350 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38351 #endif
38352 if (swig_module.next != &swig_module) {
38353 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38354 #ifdef SWIGRUNTIME_DEBUG
38355 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38356 #endif
38357 }
38358 if (ret) {
38359 if (type == swig_module.type_initial[i]) {
38360 #ifdef SWIGRUNTIME_DEBUG
38361 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38362 #endif
38363 cast->type = ret;
38364 ret = 0;
38365 } else {
38366 /* Check for casting already in the list */
38367 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38368 #ifdef SWIGRUNTIME_DEBUG
38369 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38370 #endif
38371 if (!ocast) ret = 0;
38372 }
38373 }
38374
38375 if (!ret) {
38376 #ifdef SWIGRUNTIME_DEBUG
38377 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38378 #endif
38379 if (type->cast) {
38380 type->cast->prev = cast;
38381 cast->next = type->cast;
38382 }
38383 type->cast = cast;
38384 }
38385 cast++;
38386 }
38387 /* Set entry in modules->types array equal to the type */
38388 swig_module.types[i] = type;
38389 }
38390 swig_module.types[i] = 0;
38391
38392 #ifdef SWIGRUNTIME_DEBUG
38393 printf("**** SWIG_InitializeModule: Cast List ******\n");
38394 for (i = 0; i < swig_module.size; ++i) {
38395 int j = 0;
38396 swig_cast_info *cast = swig_module.cast_initial[i];
38397 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38398 while (cast->type) {
38399 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38400 cast++;
38401 ++j;
38402 }
38403 printf("---- Total casts: %d\n",j);
38404 }
38405 printf("**** SWIG_InitializeModule: Cast List ******\n");
38406 #endif
38407 }
38408
38409 /* This function will propagate the clientdata field of type to
38410 * any new swig_type_info structures that have been added into the list
38411 * of equivalent types. It is like calling
38412 * SWIG_TypeClientData(type, clientdata) a second time.
38413 */
38414 SWIGRUNTIME void
38415 SWIG_PropagateClientData(void) {
38416 size_t i;
38417 swig_cast_info *equiv;
38418 static int init_run = 0;
38419
38420 if (init_run) return;
38421 init_run = 1;
38422
38423 for (i = 0; i < swig_module.size; i++) {
38424 if (swig_module.types[i]->clientdata) {
38425 equiv = swig_module.types[i]->cast;
38426 while (equiv) {
38427 if (!equiv->converter) {
38428 if (equiv->type && !equiv->type->clientdata)
38429 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38430 }
38431 equiv = equiv->next;
38432 }
38433 }
38434 }
38435 }
38436
38437 #ifdef __cplusplus
38438 #if 0
38439 {
38440 /* c-mode */
38441 #endif
38442 }
38443 #endif
38444
38445
38446
38447 #ifdef __cplusplus
38448 extern "C" {
38449 #endif
38450
38451 /* Python-specific SWIG API */
38452 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38453 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38454 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38455
38456 /* -----------------------------------------------------------------------------
38457 * global variable support code.
38458 * ----------------------------------------------------------------------------- */
38459
38460 typedef struct swig_globalvar {
38461 char *name; /* Name of global variable */
38462 PyObject *(*get_attr)(void); /* Return the current value */
38463 int (*set_attr)(PyObject *); /* Set the value */
38464 struct swig_globalvar *next;
38465 } swig_globalvar;
38466
38467 typedef struct swig_varlinkobject {
38468 PyObject_HEAD
38469 swig_globalvar *vars;
38470 } swig_varlinkobject;
38471
38472 SWIGINTERN PyObject *
38473 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38474 return PyString_FromString("<Swig global variables>");
38475 }
38476
38477 SWIGINTERN PyObject *
38478 swig_varlink_str(swig_varlinkobject *v) {
38479 PyObject *str = PyString_FromString("(");
38480 swig_globalvar *var;
38481 for (var = v->vars; var; var=var->next) {
38482 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38483 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38484 }
38485 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38486 return str;
38487 }
38488
38489 SWIGINTERN int
38490 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38491 PyObject *str = swig_varlink_str(v);
38492 fprintf(fp,"Swig global variables ");
38493 fprintf(fp,"%s\n", PyString_AsString(str));
38494 Py_DECREF(str);
38495 return 0;
38496 }
38497
38498 SWIGINTERN void
38499 swig_varlink_dealloc(swig_varlinkobject *v) {
38500 swig_globalvar *var = v->vars;
38501 while (var) {
38502 swig_globalvar *n = var->next;
38503 free(var->name);
38504 free(var);
38505 var = n;
38506 }
38507 }
38508
38509 SWIGINTERN PyObject *
38510 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38511 PyObject *res = NULL;
38512 swig_globalvar *var = v->vars;
38513 while (var) {
38514 if (strcmp(var->name,n) == 0) {
38515 res = (*var->get_attr)();
38516 break;
38517 }
38518 var = var->next;
38519 }
38520 if (res == NULL && !PyErr_Occurred()) {
38521 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38522 }
38523 return res;
38524 }
38525
38526 SWIGINTERN int
38527 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38528 int res = 1;
38529 swig_globalvar *var = v->vars;
38530 while (var) {
38531 if (strcmp(var->name,n) == 0) {
38532 res = (*var->set_attr)(p);
38533 break;
38534 }
38535 var = var->next;
38536 }
38537 if (res == 1 && !PyErr_Occurred()) {
38538 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38539 }
38540 return res;
38541 }
38542
38543 SWIGINTERN PyTypeObject*
38544 swig_varlink_type(void) {
38545 static char varlink__doc__[] = "Swig var link object";
38546 static PyTypeObject varlink_type;
38547 static int type_init = 0;
38548 if (!type_init) {
38549 const PyTypeObject tmp
38550 = {
38551 PyObject_HEAD_INIT(NULL)
38552 0, /* Number of items in variable part (ob_size) */
38553 (char *)"swigvarlink", /* Type name (tp_name) */
38554 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38555 0, /* Itemsize (tp_itemsize) */
38556 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38557 (printfunc) swig_varlink_print, /* Print (tp_print) */
38558 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38559 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38560 0, /* tp_compare */
38561 (reprfunc) swig_varlink_repr, /* tp_repr */
38562 0, /* tp_as_number */
38563 0, /* tp_as_sequence */
38564 0, /* tp_as_mapping */
38565 0, /* tp_hash */
38566 0, /* tp_call */
38567 (reprfunc)swig_varlink_str, /* tp_str */
38568 0, /* tp_getattro */
38569 0, /* tp_setattro */
38570 0, /* tp_as_buffer */
38571 0, /* tp_flags */
38572 varlink__doc__, /* tp_doc */
38573 0, /* tp_traverse */
38574 0, /* tp_clear */
38575 0, /* tp_richcompare */
38576 0, /* tp_weaklistoffset */
38577 #if PY_VERSION_HEX >= 0x02020000
38578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38579 #endif
38580 #if PY_VERSION_HEX >= 0x02030000
38581 0, /* tp_del */
38582 #endif
38583 #ifdef COUNT_ALLOCS
38584 0,0,0,0 /* tp_alloc -> tp_next */
38585 #endif
38586 };
38587 varlink_type = tmp;
38588 varlink_type.ob_type = &PyType_Type;
38589 type_init = 1;
38590 }
38591 return &varlink_type;
38592 }
38593
38594 /* Create a variable linking object for use later */
38595 SWIGINTERN PyObject *
38596 SWIG_Python_newvarlink(void) {
38597 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38598 if (result) {
38599 result->vars = 0;
38600 }
38601 return ((PyObject*) result);
38602 }
38603
38604 SWIGINTERN void
38605 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38606 swig_varlinkobject *v = (swig_varlinkobject *) p;
38607 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38608 if (gv) {
38609 size_t size = strlen(name)+1;
38610 gv->name = (char *)malloc(size);
38611 if (gv->name) {
38612 strncpy(gv->name,name,size);
38613 gv->get_attr = get_attr;
38614 gv->set_attr = set_attr;
38615 gv->next = v->vars;
38616 }
38617 }
38618 v->vars = gv;
38619 }
38620
38621 SWIGINTERN PyObject *
38622 SWIG_globals() {
38623 static PyObject *_SWIG_globals = 0;
38624 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38625 return _SWIG_globals;
38626 }
38627
38628 /* -----------------------------------------------------------------------------
38629 * constants/methods manipulation
38630 * ----------------------------------------------------------------------------- */
38631
38632 /* Install Constants */
38633 SWIGINTERN void
38634 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38635 PyObject *obj = 0;
38636 size_t i;
38637 for (i = 0; constants[i].type; ++i) {
38638 switch(constants[i].type) {
38639 case SWIG_PY_POINTER:
38640 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38641 break;
38642 case SWIG_PY_BINARY:
38643 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38644 break;
38645 default:
38646 obj = 0;
38647 break;
38648 }
38649 if (obj) {
38650 PyDict_SetItemString(d, constants[i].name, obj);
38651 Py_DECREF(obj);
38652 }
38653 }
38654 }
38655
38656 /* -----------------------------------------------------------------------------*/
38657 /* Fix SwigMethods to carry the callback ptrs when needed */
38658 /* -----------------------------------------------------------------------------*/
38659
38660 SWIGINTERN void
38661 SWIG_Python_FixMethods(PyMethodDef *methods,
38662 swig_const_info *const_table,
38663 swig_type_info **types,
38664 swig_type_info **types_initial) {
38665 size_t i;
38666 for (i = 0; methods[i].ml_name; ++i) {
38667 char *c = methods[i].ml_doc;
38668 if (c && (c = strstr(c, "swig_ptr: "))) {
38669 int j;
38670 swig_const_info *ci = 0;
38671 char *name = c + 10;
38672 for (j = 0; const_table[j].type; ++j) {
38673 if (strncmp(const_table[j].name, name,
38674 strlen(const_table[j].name)) == 0) {
38675 ci = &(const_table[j]);
38676 break;
38677 }
38678 }
38679 if (ci) {
38680 size_t shift = (ci->ptype) - types;
38681 swig_type_info *ty = types_initial[shift];
38682 size_t ldoc = (c - methods[i].ml_doc);
38683 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38684 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38685 if (ndoc) {
38686 char *buff = ndoc;
38687 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38688 if (ptr) {
38689 strncpy(buff, methods[i].ml_doc, ldoc);
38690 buff += ldoc;
38691 strncpy(buff, "swig_ptr: ", 10);
38692 buff += 10;
38693 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38694 methods[i].ml_doc = ndoc;
38695 }
38696 }
38697 }
38698 }
38699 }
38700 }
38701
38702 #ifdef __cplusplus
38703 }
38704 #endif
38705
38706 /* -----------------------------------------------------------------------------*
38707 * Partial Init method
38708 * -----------------------------------------------------------------------------*/
38709
38710 #ifdef __cplusplus
38711 extern "C"
38712 #endif
38713 SWIGEXPORT void SWIG_init(void) {
38714 PyObject *m, *d;
38715
38716 /* Fix SwigMethods to carry the callback ptrs when needed */
38717 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38718
38719 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38720 d = PyModule_GetDict(m);
38721
38722 SWIG_InitializeModule(0);
38723 SWIG_InstallConstants(d,swig_const_table);
38724
38725
38726 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38727 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38728 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38729 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38730 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38731 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38732 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38733 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38734 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38735 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38736 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38737 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38738 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38739 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38740 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38741 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38742 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38743 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38744 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38745 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38746 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38747 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38748 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38749 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38750 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38751 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38752 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38753 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38754 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38755 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38756 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38757 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38758 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38759 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38760 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38761 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38762 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38763 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38764 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38765 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38766 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38767 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38768 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38769 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38770 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38771 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38772 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38773 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38774 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38775 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38776 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38777 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38778 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38779 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38780 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38781 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38782 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38783 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38784 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38785 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38786 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38787 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38788 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38789 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38790 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38791 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38792 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38793 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38794 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38795 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38796 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38797 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38798 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38799 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38800 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38801 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38802 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38803 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38804 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38805 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38806 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38807 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38808 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38809 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38810 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38811 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38812 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38813 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38814 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38815 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38816 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38817 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38818 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38819 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38820 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38821 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38822 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38823 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38824 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38825 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38826 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38827 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38828
38829 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38830
38831 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38832 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38833 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38834 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38835 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38836 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38837 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38838 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38839 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38840 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38841 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38842 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38843 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38844 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38845 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38846 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38847 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38848 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38849 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38850 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38851 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38852 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38853 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38854 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38855 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38856 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38857 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38858 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38859 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38860 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38861 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38862 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38863 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38864 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38865 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38866 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38867 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38868 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38869 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38870 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38871 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38872 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38873 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38874 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38875 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38876 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38877 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38878 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38879 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38880 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38881 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38882 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38883 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38884
38885 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38886
38887 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38888 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38889 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38890 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38891 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38892 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38893 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38894 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38895 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38896 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38897 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38898 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38899 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38900 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38901 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38902 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38903 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38904 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38905 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38906 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38907 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38908 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38909 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38910 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38911 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38912 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38913 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38914 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38915 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38916 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38917 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38918 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38919 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38920 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38921 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38922 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38923 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38924 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38925 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38926 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38927 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38928 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38929 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38930 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38931 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38932 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38933 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38934 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38935 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38936 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38937 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38938 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38939 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38940 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38941 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38942 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38943 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38944 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38945 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38946 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38947 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38948 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38949 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38950 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38951 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38952 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38953 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38954 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38955 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38956 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38957 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38958 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38959 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38960 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38961 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38962 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38963
38964 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38965
38966 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38967 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38968 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38969 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38970 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38971 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38972 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38973 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38974 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38975 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38976 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38977 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38978 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38979 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38980 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38981 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38982 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38983 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38984 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38985 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38986 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38987 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38988 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38989 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38990 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38991 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38992 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38993 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38994 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38995 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38996 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38997 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38998 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38999 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39000 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39001 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39002 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39003 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39004 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39005 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39006 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39007 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39008 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39009 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39010 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39011 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39012 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39013 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39014 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39015 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39016 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39017 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39018 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39019 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39020 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39021 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39022 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39023 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39024 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39025 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39026 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39027 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39028 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39029 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39030 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39031 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39032 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39033 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39034 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39035 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39036 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39037 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39038 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39039 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39040 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39041 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39042 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39043 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39044 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39045 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39046 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39047 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39048 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39049 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39050 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39051 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39052 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39053 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39054 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39055 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39056 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39057 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39058 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39059 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39060 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39061 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39062 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39063 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39064 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39065 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39066 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39067 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39068 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39069 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39070 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39071 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39072 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39073 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39074 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39075 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39076 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39077 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39078 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39079 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39080 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39081 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39082 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39083 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39084 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39085 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39086 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39087 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39088 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39089 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39090 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39091 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39092 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39093 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39094 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39095 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39096 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39097 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39098 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39099 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39100 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39101 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39102 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39103 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39104 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39105 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39106 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39107 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39108 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39109 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39110 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39111 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39112 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39113 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39114 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39115 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39116 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39117 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39118 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39119 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39120 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39121 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39122 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39123 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39124 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39125 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39126 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39127 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39128 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39129 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39130 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39131 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39132 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39133 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39134 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39135 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39136 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39137 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39138 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39139 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39140 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39141 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39142 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39143 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39144 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39145 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39146 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39147 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39148 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39149 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39150 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39151 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39152 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39153 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39154 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39155 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39156 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39157 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39158 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39159 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39160 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39161 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39162 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39163 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39164 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39165 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39166
39167 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39168 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39169 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39170 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39171
39172 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39173 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39174 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39175 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39176 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39177 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39178 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39179 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39180 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39181 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39182 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39183 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39184 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39185 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39186 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39187 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39188 }
39189
wxWidgets (Impactor)