]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:


396da9c9130678c0103aea45bf5ae8b46facccb8
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPoint swig_types[112]
2579 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2580 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPyApp swig_types[115]
2582 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2583 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2584 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2588 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2591 #define SWIGTYPE_p_wxPyLog swig_types[125]
2592 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2593 #define SWIGTYPE_p_wxPySizer swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2598 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2599 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2600 #define SWIGTYPE_p_wxRect swig_types[134]
2601 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2602 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2603 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2604 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2606 #define SWIGTYPE_p_wxSize swig_types[140]
2607 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSizer swig_types[142]
2609 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2610 #define SWIGTYPE_p_wxSound swig_types[144]
2611 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2612 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2615 #define SWIGTYPE_p_wxString swig_types[149]
2616 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2617 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2618 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2619 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2620 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2621 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2622 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2623 #define SWIGTYPE_p_wxTimer swig_types[157]
2624 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2625 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2626 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2627 #define SWIGTYPE_p_wxToolTip swig_types[161]
2628 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2630 #define SWIGTYPE_p_wxValidator swig_types[164]
2631 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2632 #define SWIGTYPE_p_wxWindow swig_types[166]
2633 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2636 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2637 static swig_type_info *swig_types[172];
2638 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2639 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2640 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2641
2642 /* -------- TYPES TABLE (END) -------- */
2643
2644 #if (PY_VERSION_HEX <= 0x02000000)
2645 # if !defined(SWIG_PYTHON_CLASSIC)
2646 # error "This python version requires to use swig with the '-classic' option"
2647 # endif
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodern' option"
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodernargs' option"
2654 #endif
2655 #ifndef METH_O
2656 # error "This python version requires to use swig with the '-nofastunpack' option"
2657 #endif
2658
2659 /*-----------------------------------------------
2660 @(target):= _misc_.so
2661 ------------------------------------------------*/
2662 #define SWIG_init init_misc_
2663
2664 #define SWIG_name "_misc_"
2665
2666 #define SWIGVERSION 0x010329
2667
2668
2669 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2670 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2671
2672
2673 #include <stdexcept>
2674
2675
2676 namespace swig {
2677 class PyObject_ptr {
2678 protected:
2679 PyObject *_obj;
2680
2681 public:
2682 PyObject_ptr() :_obj(0)
2683 {
2684 }
2685
2686 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2687 {
2688 Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2692 {
2693 if (initial_ref) Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr & operator=(const PyObject_ptr& item)
2697 {
2698 Py_XINCREF(item._obj);
2699 Py_XDECREF(_obj);
2700 _obj = item._obj;
2701 return *this;
2702 }
2703
2704 ~PyObject_ptr()
2705 {
2706 Py_XDECREF(_obj);
2707 }
2708
2709 operator PyObject *() const
2710 {
2711 return _obj;
2712 }
2713
2714 PyObject *operator->() const
2715 {
2716 return _obj;
2717 }
2718 };
2719 }
2720
2721
2722 namespace swig {
2723 struct PyObject_var : PyObject_ptr {
2724 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2725
2726 PyObject_var & operator = (PyObject* obj)
2727 {
2728 Py_XDECREF(_obj);
2729 _obj = obj;
2730 return *this;
2731 }
2732 };
2733 }
2734
2735
2736 #include "wx/wxPython/wxPython.h"
2737 #include "wx/wxPython/pyclasses.h"
2738 #include "wx/wxPython/pyistream.h"
2739
2740 static const wxString wxPyEmptyString(wxEmptyString);
2741
2742
2743
2744 #define SWIG_From_long PyInt_FromLong
2745
2746
2747 SWIGINTERNINLINE PyObject *
2748 SWIG_From_int (int value)
2749 {
2750 return SWIG_From_long (value);
2751 }
2752
2753
2754 #include <limits.h>
2755 #ifndef LLONG_MIN
2756 # define LLONG_MIN LONG_LONG_MIN
2757 #endif
2758 #ifndef LLONG_MAX
2759 # define LLONG_MAX LONG_LONG_MAX
2760 #endif
2761 #ifndef ULLONG_MAX
2762 # define ULLONG_MAX ULONG_LONG_MAX
2763 #endif
2764
2765
2766 SWIGINTERN int
2767 SWIG_AsVal_long (PyObject* obj, long* val)
2768 {
2769 if (PyNumber_Check(obj)) {
2770 if (val) *val = PyInt_AsLong(obj);
2771 return SWIG_OK;
2772 }
2773 return SWIG_TypeError;
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_int (PyObject * obj, int *val)
2779 {
2780 long v;
2781 int res = SWIG_AsVal_long (obj, &v);
2782 if (SWIG_IsOK(res)) {
2783 if ((v < INT_MIN || v > INT_MAX)) {
2784 return SWIG_OverflowError;
2785 } else {
2786 if (val) *val = static_cast< int >(v);
2787 }
2788 }
2789 return res;
2790 }
2791
2792 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2793
2794 #include <wx/stockitem.h>
2795
2796 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2797 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2798 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2799
2800 SWIGINTERN int
2801 SWIG_AsVal_bool (PyObject *obj, bool *val)
2802 {
2803 if (obj == Py_True) {
2804 if (val) *val = true;
2805 return SWIG_OK;
2806 } else if (obj == Py_False) {
2807 if (val) *val = false;
2808 return SWIG_OK;
2809 } else {
2810 long v = 0;
2811 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2812 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2813 return res;
2814 }
2815 }
2816
2817
2818 wxMemorySize wxGetFreeMemory()
2819 { wxPyRaiseNotImplemented(); return 0; }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 void wxWakeUpMainThread() {}
2860
2861
2862 bool wxThread_IsMain() {
2863 #ifdef WXP_WITH_THREAD
2864 return wxThread::IsMain();
2865 #else
2866 return true;
2867 #endif
2868 }
2869
2870 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2871 delete self;
2872 }
2873
2874 #include <wx/snglinst.h>
2875
2876
2877 #ifdef __WXMSW__
2878 #include <wx/msw/private.h>
2879 #include <wx/dynload.h>
2880 #endif
2881
2882
2883
2884 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2885 #if 0
2886 , int method
2887 #endif
2888 )
2889 {
2890 #ifdef __WXMSW__
2891 #if 0
2892 switch (method)
2893 {
2894 case 1:
2895 // This one only partially works. Appears to be an undocumented
2896 // "standard" convention that not all widgets adhear to. For
2897 // example, for some widgets backgrounds or non-client areas may
2898 // not be painted.
2899 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2900 break;
2901
2902 case 2:
2903 #endif
2904 // This one works much better, nearly all widgets and their
2905 // children are captured correctly[**]. Prior to the big
2906 // background erase changes that Vadim did in 2004-2005 this
2907 // method failed badly on XP with Themes activated, most native
2908 // widgets draw only partially, if at all. Without themes it
2909 // worked just like on Win2k. After those changes this method
2910 // works very well.
2911 //
2912 // ** For example the radio buttons in a wxRadioBox are not its
2913 // children by default, but you can capture it via the panel
2914 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2915 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2916 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2917 PRF_ERASEBKGND | PRF_OWNED );
2918 return true;
2919 #if 0
2920 break;
2921
2922 case 3:
2923 // This one is only defined in the latest SDK and is only
2924 // available on XP. MSDN says it is similar to sending WM_PRINT
2925 // so I expect that it will work similar to the above. Since it
2926 // is avaialble only on XP, it can't be compiled like this and
2927 // will have to be loaded dynamically.
2928 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2929
2930 // fall through
2931
2932 case 4:
2933 // Use PrintWindow if available, or fallback to WM_PRINT
2934 // otherwise. Unfortunately using PrintWindow is even worse than
2935 // WM_PRINT. For most native widgets nothing is drawn to the dc
2936 // at all, with or without Themes.
2937 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2938 static bool s_triedToLoad = false;
2939 static PrintWindow_t pfnPrintWindow = NULL;
2940 if ( !s_triedToLoad )
2941 {
2942
2943 s_triedToLoad = true;
2944 wxDynamicLibrary dllUser32(_T("user32.dll"));
2945 if ( dllUser32.IsLoaded() )
2946 {
2947 wxLogNull nolog; // Don't report errors here
2948 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2949 }
2950 }
2951 if (pfnPrintWindow)
2952 {
2953 //printf("Using PrintWindow\n");
2954 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2955 }
2956 else
2957 {
2958 //printf("Using WM_PRINT\n");
2959 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2960 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2961 PRF_ERASEBKGND | PRF_OWNED );
2962 }
2963 }
2964 #endif // 0
2965 #else
2966 return false;
2967 #endif // __WXMSW__
2968 }
2969
2970
2971
2972 #include <wx/tipdlg.h>
2973
2974
2975 SWIGINTERNINLINE PyObject *
2976 SWIG_From_size_t (size_t value)
2977 {
2978 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2979 }
2980
2981
2982 class wxPyTipProvider : public wxTipProvider {
2983 public:
2984 wxPyTipProvider(size_t currentTip)
2985 : wxTipProvider(currentTip) {}
2986
2987 DEC_PYCALLBACK_STRING__pure(GetTip);
2988 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2989 PYPRIVATE;
2990 };
2991
2992 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2993 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2994
2995
2996 SWIGINTERNINLINE int
2997 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2998 {
2999 unsigned long v;
3000 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3001 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3002 return res;
3003 }
3004
3005
3006 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3007
3008 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3009
3010 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3011 : wxTimer(owner, id)
3012 {
3013 if (owner == NULL)
3014 SetOwner(this);
3015 }
3016
3017
3018 SWIGINTERN swig_type_info*
3019 SWIG_pchar_descriptor()
3020 {
3021 static int init = 0;
3022 static swig_type_info* info = 0;
3023 if (!init) {
3024 info = SWIG_TypeQuery("_p_char");
3025 init = 1;
3026 }
3027 return info;
3028 }
3029
3030
3031 SWIGINTERNINLINE PyObject *
3032 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3033 {
3034 if (carray) {
3035 if (size > INT_MAX) {
3036 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3037 return pchar_descriptor ?
3038 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3039 } else {
3040 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3041 }
3042 } else {
3043 return SWIG_Py_Void();
3044 }
3045 }
3046
3047
3048 SWIGINTERNINLINE PyObject *
3049 SWIG_FromCharPtr(const char *cptr)
3050 {
3051 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3052 }
3053
3054
3055 SWIGINTERN int
3056 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3057 {
3058 unsigned long v;
3059 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3060 if (SWIG_IsOK(res)) {
3061 if ((v > UINT_MAX)) {
3062 return SWIG_OverflowError;
3063 } else {
3064 if (val) *val = static_cast< unsigned int >(v);
3065 }
3066 }
3067 return res;
3068 }
3069
3070 SWIGINTERN wxString wxLog_TimeStamp(){
3071 wxString msg;
3072 wxLog::TimeStamp(&msg);
3073 return msg;
3074 }
3075 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3076 // Make some wrappers that double any % signs so they are 'escaped'
3077 void wxPyLogFatalError(const wxString& msg)
3078 {
3079 wxString m(msg);
3080 m.Replace(wxT("%"), wxT("%%"));
3081 wxLogFatalError(m);
3082 }
3083
3084 void wxPyLogError(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogError(m);
3089 }
3090
3091 void wxPyLogWarning(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogWarning(m);
3096 }
3097
3098 void wxPyLogMessage(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogMessage(m);
3103 }
3104
3105 void wxPyLogInfo(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogInfo(m);
3110 }
3111
3112 void wxPyLogDebug(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogDebug(m);
3117 }
3118
3119 void wxPyLogVerbose(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogVerbose(m);
3124 }
3125
3126 void wxPyLogStatus(const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogStatus(m);
3131 }
3132
3133 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogStatus(pFrame, m);
3138 }
3139
3140 void wxPyLogSysError(const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogSysError(m);
3145 }
3146
3147 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogGeneric(level, m);
3152 }
3153
3154 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogTrace(mask, m);
3159 }
3160
3161 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3162 {
3163 wxString m(msg);
3164 m.Replace(wxT("%"), wxT("%%"));
3165 wxLogTrace(mask, m);
3166 }
3167
3168
3169
3170 // A wxLog class that can be derived from in wxPython
3171 class wxPyLog : public wxLog {
3172 public:
3173 wxPyLog() : wxLog() {}
3174
3175 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3176 bool found;
3177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3178 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3179 PyObject* s = wx2PyString(szString);
3180 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3181 Py_DECREF(s);
3182 }
3183 wxPyEndBlockThreads(blocked);
3184 if (! found)
3185 wxLog::DoLog(level, szString, t);
3186 }
3187
3188 virtual void DoLogString(const wxChar *szString, time_t t) {
3189 bool found;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3192 PyObject* s = wx2PyString(szString);
3193 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3194 Py_DECREF(s);
3195 }
3196 wxPyEndBlockThreads(blocked);
3197 if (! found)
3198 wxLog::DoLogString(szString, t);
3199 }
3200
3201 DEC_PYCALLBACK_VOID_(Flush);
3202 PYPRIVATE;
3203 };
3204 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3205
3206
3207
3208
3209 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3210
3211
3212 #include <wx/joystick.h>
3213
3214
3215 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3216 // A C++ stub class for wxJoystick for platforms that don't have it.
3217 class wxJoystick : public wxObject {
3218 public:
3219 wxJoystick(int joystick = wxJOYSTICK1) {
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 PyErr_SetString(PyExc_NotImplementedError,
3222 "wxJoystick is not available on this platform.");
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 wxPoint GetPosition() { return wxPoint(-1,-1); }
3226 int GetZPosition() { return -1; }
3227 int GetButtonState() { return -1; }
3228 int GetPOVPosition() { return -1; }
3229 int GetPOVCTSPosition() { return -1; }
3230 int GetRudderPosition() { return -1; }
3231 int GetUPosition() { return -1; }
3232 int GetVPosition() { return -1; }
3233 int GetMovementThreshold() { return -1; }
3234 void SetMovementThreshold(int threshold) {}
3235
3236 bool IsOk(void) { return false; }
3237 int GetNumberJoysticks() { return -1; }
3238 int GetManufacturerId() { return -1; }
3239 int GetProductId() { return -1; }
3240 wxString GetProductName() { return wxEmptyString; }
3241 int GetXMin() { return -1; }
3242 int GetYMin() { return -1; }
3243 int GetZMin() { return -1; }
3244 int GetXMax() { return -1; }
3245 int GetYMax() { return -1; }
3246 int GetZMax() { return -1; }
3247 int GetNumberButtons() { return -1; }
3248 int GetNumberAxes() { return -1; }
3249 int GetMaxButtons() { return -1; }
3250 int GetMaxAxes() { return -1; }
3251 int GetPollingMin() { return -1; }
3252 int GetPollingMax() { return -1; }
3253 int GetRudderMin() { return -1; }
3254 int GetRudderMax() { return -1; }
3255 int GetUMin() { return -1; }
3256 int GetUMax() { return -1; }
3257 int GetVMin() { return -1; }
3258 int GetVMax() { return -1; }
3259
3260 bool HasRudder() { return false; }
3261 bool HasZ() { return false; }
3262 bool HasU() { return false; }
3263 bool HasV() { return false; }
3264 bool HasPOV() { return false; }
3265 bool HasPOV4Dir() { return false; }
3266 bool HasPOVCTS() { return false; }
3267
3268 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3269 bool ReleaseCapture() { return false; }
3270 };
3271 #endif
3272
3273
3274 #include <wx/sound.h>
3275
3276
3277 #if !wxUSE_SOUND
3278 // A C++ stub class for wxWave for platforms that don't have it.
3279 class wxSound : public wxObject
3280 {
3281 public:
3282 wxSound() {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(const wxString&/*, bool*/) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294 wxSound(int, const wxByte*) {
3295 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3296 PyErr_SetString(PyExc_NotImplementedError,
3297 "wxSound is not available on this platform.");
3298 wxPyEndBlockThreads(blocked);
3299 }
3300
3301 ~wxSound() {};
3302
3303 bool Create(const wxString&/*, bool*/) { return false; }
3304 bool Create(int, const wxByte*) { return false; };
3305 bool IsOk() { return false; };
3306 bool Play(unsigned) const { return false; }
3307 static bool Play(const wxString&, unsigned) { return false; }
3308 static void Stop() {}
3309 };
3310
3311 #endif
3312
3313 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3314 if (fileName.Length() == 0)
3315 return new wxSound;
3316 else
3317 return new wxSound(fileName);
3318 }
3319 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3320 unsigned char* buffer; int size;
3321 wxSound *sound = NULL;
3322
3323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3324 if (!PyArg_Parse(data, "t#", &buffer, &size))
3325 goto done;
3326 sound = new wxSound(size, buffer);
3327 done:
3328 wxPyEndBlockThreads(blocked);
3329 return sound;
3330 }
3331 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3332 #ifndef __WXMAC__
3333 unsigned char* buffer;
3334 int size;
3335 bool rv = false;
3336
3337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3338 if (!PyArg_Parse(data, "t#", &buffer, &size))
3339 goto done;
3340 rv = self->Create(size, buffer);
3341 done:
3342 wxPyEndBlockThreads(blocked);
3343 return rv;
3344 #else
3345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3346 PyErr_SetString(PyExc_NotImplementedError,
3347 "Create from data is not available on this platform.");
3348 wxPyEndBlockThreads(blocked);
3349 return false;
3350 #endif
3351 }
3352
3353 #include <wx/mimetype.h>
3354
3355 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3356 wxString str;
3357 if (self->GetMimeType(&str))
3358 return wx2PyString(str);
3359 else
3360 RETURN_NONE();
3361 }
3362 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3363 wxArrayString arr;
3364 if (self->GetMimeTypes(arr))
3365 return wxArrayString2PyList_helper(arr);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3370 wxArrayString arr;
3371 if (self->GetExtensions(arr))
3372 return wxArrayString2PyList_helper(arr);
3373 else
3374 RETURN_NONE();
3375 }
3376 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3377 wxIconLocation loc;
3378 if (self->GetIcon(&loc))
3379 return new wxIcon(loc);
3380 else
3381 return NULL;
3382 }
3383 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3384 wxIconLocation loc;
3385 if (self->GetIcon(&loc)) {
3386 wxString iconFile = loc.GetFileName();
3387 int iconIndex = -1;
3388
3389
3390
3391 // Make a tuple and put the values in it
3392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3393 PyObject* tuple = PyTuple_New(3);
3394 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3395 wxT("wxIcon"), true));
3396 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3397 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3398 wxPyEndBlockThreads(blocked);
3399 return tuple;
3400 }
3401 else
3402 RETURN_NONE();
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3405 wxString str;
3406 if (self->GetDescription(&str))
3407 return wx2PyString(str);
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3412 wxString str;
3413 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxString str;
3420 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3421 return wx2PyString(str);
3422 else
3423 RETURN_NONE();
3424 }
3425 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3426 wxArrayString verbs;
3427 wxArrayString commands;
3428 if (self->GetAllCommands(&verbs, &commands,
3429 wxFileType::MessageParameters(filename, mimetype))) {
3430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3431 PyObject* tuple = PyTuple_New(2);
3432 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3433 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3434 wxPyEndBlockThreads(blocked);
3435 return tuple;
3436 }
3437 else
3438 RETURN_NONE();
3439 }
3440 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3441 return wxFileType::ExpandCommand(command,
3442 wxFileType::MessageParameters(filename, mimetype));
3443 }
3444 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3445 wxArrayString arr;
3446 self->EnumAllFileTypes(arr);
3447 return wxArrayString2PyList_helper(arr);
3448 }
3449
3450 #include <wx/artprov.h>
3451
3452 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3453 static const wxString wxPyART_MENU(wxART_MENU);
3454 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3455 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3456 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3457 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3458 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3459 static const wxString wxPyART_OTHER(wxART_OTHER);
3460 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3461 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3462 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3463 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3464 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3465 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3466 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3467 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3468 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3469 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3470 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3471 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3472 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3473 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3474 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3475 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3476 static const wxString wxPyART_PRINT(wxART_PRINT);
3477 static const wxString wxPyART_HELP(wxART_HELP);
3478 static const wxString wxPyART_TIP(wxART_TIP);
3479 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3480 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3481 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3482 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3483 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3484 static const wxString wxPyART_CDROM(wxART_CDROM);
3485 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3486 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3487 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3488 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3489 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3490 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3491 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3492 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3493 static const wxString wxPyART_ERROR(wxART_ERROR);
3494 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3495 static const wxString wxPyART_WARNING(wxART_WARNING);
3496 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3497 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3498 static const wxString wxPyART_COPY(wxART_COPY);
3499 static const wxString wxPyART_CUT(wxART_CUT);
3500 static const wxString wxPyART_PASTE(wxART_PASTE);
3501 static const wxString wxPyART_DELETE(wxART_DELETE);
3502 static const wxString wxPyART_NEW(wxART_NEW);
3503 static const wxString wxPyART_UNDO(wxART_UNDO);
3504 static const wxString wxPyART_REDO(wxART_REDO);
3505 static const wxString wxPyART_QUIT(wxART_QUIT);
3506 static const wxString wxPyART_FIND(wxART_FIND);
3507 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3508 // Python aware wxArtProvider
3509 class wxPyArtProvider : public wxArtProvider {
3510 public:
3511
3512 virtual wxBitmap CreateBitmap(const wxArtID& id,
3513 const wxArtClient& client,
3514 const wxSize& size) {
3515 wxBitmap rval = wxNullBitmap;
3516 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3517 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3518 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3519 PyObject* ro;
3520 wxBitmap* ptr;
3521 PyObject* s1, *s2;
3522 s1 = wx2PyString(id);
3523 s2 = wx2PyString(client);
3524 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3525 Py_DECREF(so);
3526 Py_DECREF(s1);
3527 Py_DECREF(s2);
3528 if (ro) {
3529 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3530 rval = *ptr;
3531 Py_DECREF(ro);
3532 }
3533 }
3534 wxPyEndBlockThreads(blocked);
3535 return rval;
3536 }
3537
3538 PYPRIVATE;
3539 };
3540
3541 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3542
3543
3544
3545 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3546 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3547 PyObject* ret = PyTuple_New(3);
3548 if (ret) {
3549 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3550 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3551 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3552 }
3553 wxPyEndBlockThreads(blocked);
3554 return ret;
3555 }
3556
3557 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3558 bool cont;
3559 long index = 0;
3560 wxString value;
3561
3562 cont = self->GetFirstGroup(value, index);
3563 return __EnumerationHelper(cont, value, index);
3564 }
3565 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3566 bool cont;
3567 wxString value;
3568
3569 cont = self->GetNextGroup(value, index);
3570 return __EnumerationHelper(cont, value, index);
3571 }
3572 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3573 bool cont;
3574 long index = 0;
3575 wxString value;
3576
3577 cont = self->GetFirstEntry(value, index);
3578 return __EnumerationHelper(cont, value, index);
3579 }
3580 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3581 bool cont;
3582 wxString value;
3583
3584 cont = self->GetNextEntry(value, index);
3585 return __EnumerationHelper(cont, value, index);
3586 }
3587 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3588 long rv;
3589 self->Read(key, &rv, defaultVal);
3590 return rv;
3591 }
3592
3593 SWIGINTERN int
3594 SWIG_AsVal_double (PyObject *obj, double* val)
3595 {
3596 if (PyNumber_Check(obj)) {
3597 if (val) *val = PyFloat_AsDouble(obj);
3598 return SWIG_OK;
3599 }
3600 return SWIG_TypeError;
3601 }
3602
3603 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3604 double rv;
3605 self->Read(key, &rv, defaultVal);
3606 return rv;
3607 }
3608
3609 #define SWIG_From_double PyFloat_FromDouble
3610
3611 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3612 bool rv;
3613 self->Read(key, &rv, defaultVal);
3614 return rv;
3615 }
3616
3617 #include <wx/datetime.h>
3618
3619 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3620 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3621
3622 #define LOCAL_TZ wxDateTime::Local
3623
3624 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3625 wxString am;
3626 wxString pm;
3627 wxDateTime::GetAmPmStrings(&am, &pm);
3628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3629 PyObject* tup = PyTuple_New(2);
3630 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3631 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3632 wxPyEndBlockThreads(blocked);
3633 return tup;
3634 }
3635
3636 SWIGINTERNINLINE PyObject *
3637 SWIG_From_unsigned_SS_int (unsigned int value)
3638 {
3639 return SWIG_From_unsigned_SS_long (value);
3640 }
3641
3642 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3644 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3645 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3647 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3649 return (*self < *other);
3650 }
3651 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3653 return (*self <= *other);
3654 }
3655 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3657 return (*self > *other);
3658 }
3659 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3661 return (*self >= *other);
3662 }
3663 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3665 return (*self == *other);
3666 }
3667 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3668 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3669 return (*self != *other);
3670 }
3671 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3672 const wxChar* rv;
3673 const wxChar* _date = date;
3674 rv = self->ParseRfc822Date(_date);
3675 if (rv == NULL) return -1;
3676 return rv - _date;
3677 }
3678 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3679 const wxChar* rv;
3680 const wxChar* _date = date;
3681 rv = self->ParseFormat(_date, format, dateDef);
3682 if (rv == NULL) return -1;
3683 return rv - _date;
3684 }
3685 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3686 const wxChar* rv;
3687 const wxChar* _datetime = datetime;
3688 rv = self->ParseDateTime(_datetime);
3689 if (rv == NULL) return -1;
3690 return rv - _datetime;
3691 }
3692 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3693 const wxChar* rv;
3694 const wxChar* _date = date;
3695 rv = self->ParseDate(_date);
3696 if (rv == NULL) return -1;
3697 return rv - _date;
3698 }
3699 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3700 const wxChar* rv;
3701 const wxChar* _time = time;
3702 rv = self->ParseTime(_time);
3703 if (rv == NULL) return -1;
3704 return rv - _time;
3705 }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3710 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3713 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3716 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3717 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3719 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3720 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3721 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3722
3723 #include <wx/dataobj.h>
3724
3725 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3726 size_t count = self->GetFormatCount(dir);
3727 wxDataFormat* formats = new wxDataFormat[count];
3728 self->GetAllFormats(formats, dir);
3729
3730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3731 PyObject* list = PyList_New(count);
3732 for (size_t i=0; i<count; i++) {
3733 wxDataFormat* format = new wxDataFormat(formats[i]);
3734 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3735 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3736 }
3737 wxPyEndBlockThreads(blocked);
3738 delete [] formats;
3739 return list;
3740 }
3741 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3742 PyObject* rval = NULL;
3743 size_t size = self->GetDataSize(format);
3744 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3745 if (size) {
3746 char* buf = new char[size];
3747 if (self->GetDataHere(format, buf))
3748 rval = PyString_FromStringAndSize(buf, size);
3749 delete [] buf;
3750 }
3751 if (! rval) {
3752 rval = Py_None;
3753 Py_INCREF(rval);
3754 }
3755 wxPyEndBlockThreads(blocked);
3756 return rval;
3757 }
3758 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3759 bool rval;
3760 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3761 if (PyString_Check(data)) {
3762 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3763 }
3764 else {
3765 // raise a TypeError if not a string
3766 PyErr_SetString(PyExc_TypeError, "String expected.");
3767 rval = false;
3768 }
3769 wxPyEndBlockThreads(blocked);
3770 return rval;
3771 }
3772 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3773 PyObject* rval = NULL;
3774 size_t size = self->GetDataSize();
3775 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3776 if (size) {
3777 char* buf = new char[size];
3778 if (self->GetDataHere(buf))
3779 rval = PyString_FromStringAndSize(buf, size);
3780 delete [] buf;
3781 }
3782 if (! rval) {
3783 rval = Py_None;
3784 Py_INCREF(rval);
3785 }
3786 wxPyEndBlockThreads(blocked);
3787 return rval;
3788 }
3789 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3790 bool rval;
3791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3792 if (PyString_Check(data)) {
3793 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3794 }
3795 else {
3796 // raise a TypeError if not a string
3797 PyErr_SetString(PyExc_TypeError, "String expected.");
3798 rval = false;
3799 }
3800 wxPyEndBlockThreads(blocked);
3801 return rval;
3802 }
3803 // Create a new class for wxPython to use
3804 class wxPyDataObjectSimple : public wxDataObjectSimple {
3805 public:
3806 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3807 : wxDataObjectSimple(format) {}
3808
3809 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3810 bool GetDataHere(void *buf) const;
3811 bool SetData(size_t len, const void *buf) const;
3812 PYPRIVATE;
3813 };
3814
3815 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3816
3817 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3818 // We need to get the data for this object and write it to buf. I think
3819 // the best way to do this for wxPython is to have the Python method
3820 // return either a string or None and then act appropriately with the
3821 // C++ version.
3822
3823 bool rval = false;
3824 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3825 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3826 PyObject* ro;
3827 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3828 if (ro) {
3829 rval = (ro != Py_None && PyString_Check(ro));
3830 if (rval)
3831 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3832 Py_DECREF(ro);
3833 }
3834 }
3835 wxPyEndBlockThreads(blocked);
3836 return rval;
3837 }
3838
3839 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3840 // For this one we simply need to make a string from buf and len
3841 // and send it to the Python method.
3842 bool rval = false;
3843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3844 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3845 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3846 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3847 Py_DECREF(data);
3848 }
3849 wxPyEndBlockThreads(blocked);
3850 return rval;
3851 }
3852
3853 // Create a new class for wxPython to use
3854 class wxPyTextDataObject : public wxTextDataObject {
3855 public:
3856 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3857 : wxTextDataObject(text) {}
3858
3859 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3860 DEC_PYCALLBACK_STRING__const(GetText);
3861 DEC_PYCALLBACK__STRING(SetText);
3862 PYPRIVATE;
3863 };
3864
3865 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3866 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3867 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3868
3869
3870 // Create a new class for wxPython to use
3871 class wxPyBitmapDataObject : public wxBitmapDataObject {
3872 public:
3873 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3874 : wxBitmapDataObject(bitmap) {}
3875
3876 wxBitmap GetBitmap() const;
3877 void SetBitmap(const wxBitmap& bitmap);
3878 PYPRIVATE;
3879 };
3880
3881 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3882 wxBitmap* rval = &wxNullBitmap;
3883 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3884 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3885 PyObject* ro;
3886 wxBitmap* ptr;
3887 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3888 if (ro) {
3889 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3890 rval = ptr;
3891 Py_DECREF(ro);
3892 }
3893 }
3894 wxPyEndBlockThreads(blocked);
3895 return *rval;
3896 }
3897
3898 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3900 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3901 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3902 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3903 Py_DECREF(bo);
3904 }
3905 wxPyEndBlockThreads(blocked);
3906 }
3907
3908 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3909 return new wxCustomDataObject(wxDataFormat(formatName));
3910 }
3911 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3912 bool rval;
3913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3914 if (PyString_Check(data)) {
3915 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3916 }
3917 else {
3918 // raise a TypeError if not a string
3919 PyErr_SetString(PyExc_TypeError, "String expected.");
3920 rval = false;
3921 }
3922 wxPyEndBlockThreads(blocked);
3923 return rval;
3924 }
3925 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3926 PyObject* obj;
3927 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3928 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3929 wxPyEndBlockThreads(blocked);
3930 return obj;
3931 }
3932
3933 class wxMetafileDataObject : public wxDataObjectSimple
3934 {
3935 public:
3936 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3937 };
3938
3939
3940 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3941
3942
3943 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3946 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3947 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3948
3949
3950 class wxPyTextDropTarget : public wxTextDropTarget {
3951 public:
3952 wxPyTextDropTarget() {}
3953
3954 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3955
3956 DEC_PYCALLBACK__(OnLeave);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3960 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3961
3962 PYPRIVATE;
3963 };
3964
3965 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3966 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3970 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3971
3972
3973
3974 class wxPyFileDropTarget : public wxFileDropTarget {
3975 public:
3976 wxPyFileDropTarget() {}
3977
3978 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3979
3980 DEC_PYCALLBACK__(OnLeave);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3984 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3985
3986 PYPRIVATE;
3987 };
3988
3989 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3990 const wxArrayString& filenames) {
3991 bool rval = false;
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3994 PyObject* list = wxArrayString2PyList_helper(filenames);
3995 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3996 Py_DECREF(list);
3997 }
3998 wxPyEndBlockThreads(blocked);
3999 return rval;
4000 }
4001
4002
4003
4004 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4009
4010
4011
4012
4013 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4014
4015 #include <wx/display.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073
4074 #ifndef wxHAS_POWER_EVENTS
4075 // Dummy class and other definitions for platforms that don't have them
4076
4077 // See wxPython_int.h for wxPowerEvent
4078
4079 enum {
4080 wxEVT_POWER_SUSPENDING,
4081 wxEVT_POWER_SUSPENDED,
4082 wxEVT_POWER_SUSPEND_CANCEL,
4083 wxEVT_POWER_RESUME,
4084 };
4085
4086 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4087 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4088
4089 #endif
4090
4091 #ifdef __cplusplus
4092 extern "C" {
4093 #endif
4094 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj = 0;
4096 wxSystemColour arg1 ;
4097 wxColour result;
4098 int val1 ;
4099 int ecode1 = 0 ;
4100 PyObject * obj0 = 0 ;
4101 char * kwnames[] = {
4102 (char *) "index", NULL
4103 };
4104
4105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4106 ecode1 = SWIG_AsVal_int(obj0, &val1);
4107 if (!SWIG_IsOK(ecode1)) {
4108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4109 }
4110 arg1 = static_cast< wxSystemColour >(val1);
4111 {
4112 if (!wxPyCheckForApp()) SWIG_fail;
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = wxSystemSettings::GetColour(arg1);
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 wxSystemFont arg1 ;
4128 wxFont result;
4129 int val1 ;
4130 int ecode1 = 0 ;
4131 PyObject * obj0 = 0 ;
4132 char * kwnames[] = {
4133 (char *) "index", NULL
4134 };
4135
4136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4137 ecode1 = SWIG_AsVal_int(obj0, &val1);
4138 if (!SWIG_IsOK(ecode1)) {
4139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4140 }
4141 arg1 = static_cast< wxSystemFont >(val1);
4142 {
4143 if (!wxPyCheckForApp()) SWIG_fail;
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 result = wxSystemSettings::GetFont(arg1);
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4150 return resultobj;
4151 fail:
4152 return NULL;
4153 }
4154
4155
4156 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4157 PyObject *resultobj = 0;
4158 wxSystemMetric arg1 ;
4159 wxWindow *arg2 = (wxWindow *) NULL ;
4160 int result;
4161 int val1 ;
4162 int ecode1 = 0 ;
4163 void *argp2 = 0 ;
4164 int res2 = 0 ;
4165 PyObject * obj0 = 0 ;
4166 PyObject * obj1 = 0 ;
4167 char * kwnames[] = {
4168 (char *) "index",(char *) "win", NULL
4169 };
4170
4171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4172 ecode1 = SWIG_AsVal_int(obj0, &val1);
4173 if (!SWIG_IsOK(ecode1)) {
4174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4175 }
4176 arg1 = static_cast< wxSystemMetric >(val1);
4177 if (obj1) {
4178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4179 if (!SWIG_IsOK(res2)) {
4180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4181 }
4182 arg2 = reinterpret_cast< wxWindow * >(argp2);
4183 }
4184 {
4185 if (!wxPyCheckForApp()) SWIG_fail;
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 resultobj = SWIG_From_int(static_cast< int >(result));
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = 0;
4200 wxSystemFeature arg1 ;
4201 bool result;
4202 int val1 ;
4203 int ecode1 = 0 ;
4204 PyObject * obj0 = 0 ;
4205 char * kwnames[] = {
4206 (char *) "index", NULL
4207 };
4208
4209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4210 ecode1 = SWIG_AsVal_int(obj0, &val1);
4211 if (!SWIG_IsOK(ecode1)) {
4212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4213 }
4214 arg1 = static_cast< wxSystemFeature >(val1);
4215 {
4216 if (!wxPyCheckForApp()) SWIG_fail;
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = (bool)wxSystemSettings::HasFeature(arg1);
4219 wxPyEndAllowThreads(__tstate);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 {
4223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4224 }
4225 return resultobj;
4226 fail:
4227 return NULL;
4228 }
4229
4230
4231 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4232 PyObject *resultobj = 0;
4233 wxSystemScreenType result;
4234
4235 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4236 {
4237 if (!wxPyCheckForApp()) SWIG_fail;
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 resultobj = SWIG_From_int(static_cast< int >(result));
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj = 0;
4252 wxSystemScreenType arg1 ;
4253 int val1 ;
4254 int ecode1 = 0 ;
4255 PyObject * obj0 = 0 ;
4256 char * kwnames[] = {
4257 (char *) "screen", NULL
4258 };
4259
4260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4261 ecode1 = SWIG_AsVal_int(obj0, &val1);
4262 if (!SWIG_IsOK(ecode1)) {
4263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4264 }
4265 arg1 = static_cast< wxSystemScreenType >(val1);
4266 {
4267 if (!wxPyCheckForApp()) SWIG_fail;
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 wxSystemSettings::SetScreenType(arg1);
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 resultobj = SWIG_Py_Void();
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4281 PyObject *obj;
4282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4284 return SWIG_Py_Void();
4285 }
4286
4287 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4288 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4289 return 1;
4290 }
4291
4292
4293 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4294 PyObject *pyobj = 0;
4295
4296 {
4297 #if wxUSE_UNICODE
4298 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4299 #else
4300 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4301 #endif
4302 }
4303 return pyobj;
4304 }
4305
4306
4307 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxSystemOptions *result = 0 ;
4310
4311 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (wxSystemOptions *)new wxSystemOptions();
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj = 0;
4327 wxString *arg1 = 0 ;
4328 wxString *arg2 = 0 ;
4329 bool temp1 = false ;
4330 bool temp2 = false ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char * kwnames[] = {
4334 (char *) "name",(char *) "value", NULL
4335 };
4336
4337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4338 {
4339 arg1 = wxString_in_helper(obj0);
4340 if (arg1 == NULL) SWIG_fail;
4341 temp1 = true;
4342 }
4343 {
4344 arg2 = wxString_in_helper(obj1);
4345 if (arg2 == NULL) SWIG_fail;
4346 temp2 = true;
4347 }
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 resultobj = SWIG_Py_Void();
4355 {
4356 if (temp1)
4357 delete arg1;
4358 }
4359 {
4360 if (temp2)
4361 delete arg2;
4362 }
4363 return resultobj;
4364 fail:
4365 {
4366 if (temp1)
4367 delete arg1;
4368 }
4369 {
4370 if (temp2)
4371 delete arg2;
4372 }
4373 return NULL;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj = 0;
4379 wxString *arg1 = 0 ;
4380 int arg2 ;
4381 bool temp1 = false ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char * kwnames[] = {
4387 (char *) "name",(char *) "value", NULL
4388 };
4389
4390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4391 {
4392 arg1 = wxString_in_helper(obj0);
4393 if (arg1 == NULL) SWIG_fail;
4394 temp1 = true;
4395 }
4396 ecode2 = SWIG_AsVal_int(obj1, &val2);
4397 if (!SWIG_IsOK(ecode2)) {
4398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4399 }
4400 arg2 = static_cast< int >(val2);
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4404 wxPyEndAllowThreads(__tstate);
4405 if (PyErr_Occurred()) SWIG_fail;
4406 }
4407 resultobj = SWIG_Py_Void();
4408 {
4409 if (temp1)
4410 delete arg1;
4411 }
4412 return resultobj;
4413 fail:
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return NULL;
4419 }
4420
4421
4422 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4423 PyObject *resultobj = 0;
4424 wxString *arg1 = 0 ;
4425 wxString result;
4426 bool temp1 = false ;
4427 PyObject * obj0 = 0 ;
4428 char * kwnames[] = {
4429 (char *) "name", NULL
4430 };
4431
4432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4433 {
4434 arg1 = wxString_in_helper(obj0);
4435 if (arg1 == NULL) SWIG_fail;
4436 temp1 = true;
4437 }
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4441 wxPyEndAllowThreads(__tstate);
4442 if (PyErr_Occurred()) SWIG_fail;
4443 }
4444 {
4445 #if wxUSE_UNICODE
4446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4447 #else
4448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4449 #endif
4450 }
4451 {
4452 if (temp1)
4453 delete arg1;
4454 }
4455 return resultobj;
4456 fail:
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return NULL;
4462 }
4463
4464
4465 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj = 0;
4467 wxString *arg1 = 0 ;
4468 int result;
4469 bool temp1 = false ;
4470 PyObject * obj0 = 0 ;
4471 char * kwnames[] = {
4472 (char *) "name", NULL
4473 };
4474
4475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4476 {
4477 arg1 = wxString_in_helper(obj0);
4478 if (arg1 == NULL) SWIG_fail;
4479 temp1 = true;
4480 }
4481 {
4482 PyThreadState* __tstate = wxPyBeginAllowThreads();
4483 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 resultobj = SWIG_From_int(static_cast< int >(result));
4488 {
4489 if (temp1)
4490 delete arg1;
4491 }
4492 return resultobj;
4493 fail:
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxString *arg1 = 0 ;
4505 bool result;
4506 bool temp1 = false ;
4507 PyObject * obj0 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "name", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4513 {
4514 arg1 = wxString_in_helper(obj0);
4515 if (arg1 == NULL) SWIG_fail;
4516 temp1 = true;
4517 }
4518 {
4519 PyThreadState* __tstate = wxPyBeginAllowThreads();
4520 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 {
4528 if (temp1)
4529 delete arg1;
4530 }
4531 return resultobj;
4532 fail:
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return NULL;
4538 }
4539
4540
4541 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj = 0;
4543 wxString *arg1 = 0 ;
4544 bool result;
4545 bool temp1 = false ;
4546 PyObject * obj0 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "name", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4552 {
4553 arg1 = wxString_in_helper(obj0);
4554 if (arg1 == NULL) SWIG_fail;
4555 temp1 = true;
4556 }
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 {
4564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4565 }
4566 {
4567 if (temp1)
4568 delete arg1;
4569 }
4570 return resultobj;
4571 fail:
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return NULL;
4577 }
4578
4579
4580 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 PyObject *obj;
4582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4583 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4584 return SWIG_Py_Void();
4585 }
4586
4587 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 return SWIG_Python_InitShadowInstance(args);
4589 }
4590
4591 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4592 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4593 return 1;
4594 }
4595
4596
4597 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4598 PyObject *pyobj = 0;
4599
4600 {
4601 #if wxUSE_UNICODE
4602 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4603 #else
4604 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4605 #endif
4606 }
4607 return pyobj;
4608 }
4609
4610
4611 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4612 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4613 return 1;
4614 }
4615
4616
4617 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4618 PyObject *pyobj = 0;
4619
4620 {
4621 #if wxUSE_UNICODE
4622 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4623 #else
4624 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4625 #endif
4626 }
4627 return pyobj;
4628 }
4629
4630
4631 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4632 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4633 return 1;
4634 }
4635
4636
4637 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4638 PyObject *pyobj = 0;
4639
4640 {
4641 #if wxUSE_UNICODE
4642 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4643 #else
4644 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4645 #endif
4646 }
4647 return pyobj;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 long result;
4654
4655 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 result = (long)wxNewId();
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_From_long(static_cast< long >(result));
4663 return resultobj;
4664 fail:
4665 return NULL;
4666 }
4667
4668
4669 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4670 PyObject *resultobj = 0;
4671 long arg1 ;
4672 long val1 ;
4673 int ecode1 = 0 ;
4674 PyObject * obj0 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "id", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4680 ecode1 = SWIG_AsVal_long(obj0, &val1);
4681 if (!SWIG_IsOK(ecode1)) {
4682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4683 }
4684 arg1 = static_cast< long >(val1);
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 wxRegisterId(arg1);
4688 wxPyEndAllowThreads(__tstate);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 resultobj = SWIG_Py_Void();
4692 return resultobj;
4693 fail:
4694 return NULL;
4695 }
4696
4697
4698 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4699 PyObject *resultobj = 0;
4700 long result;
4701
4702 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4703 {
4704 PyThreadState* __tstate = wxPyBeginAllowThreads();
4705 result = (long)wxGetCurrentId();
4706 wxPyEndAllowThreads(__tstate);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_From_long(static_cast< long >(result));
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4717 PyObject *resultobj = 0;
4718 int arg1 ;
4719 bool result;
4720 int val1 ;
4721 int ecode1 = 0 ;
4722 PyObject * obj0 = 0 ;
4723 char * kwnames[] = {
4724 (char *) "id", NULL
4725 };
4726
4727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4728 ecode1 = SWIG_AsVal_int(obj0, &val1);
4729 if (!SWIG_IsOK(ecode1)) {
4730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4731 }
4732 arg1 = static_cast< int >(val1);
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (bool)wxIsStockID(arg1);
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 {
4740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4741 }
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4749 PyObject *resultobj = 0;
4750 int arg1 ;
4751 wxString *arg2 = 0 ;
4752 bool result;
4753 int val1 ;
4754 int ecode1 = 0 ;
4755 bool temp2 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 char * kwnames[] = {
4759 (char *) "id",(char *) "label", NULL
4760 };
4761
4762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4763 ecode1 = SWIG_AsVal_int(obj0, &val1);
4764 if (!SWIG_IsOK(ecode1)) {
4765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4766 }
4767 arg1 = static_cast< int >(val1);
4768 {
4769 arg2 = wxString_in_helper(obj1);
4770 if (arg2 == NULL) SWIG_fail;
4771 temp2 = true;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 {
4780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4781 }
4782 {
4783 if (temp2)
4784 delete arg2;
4785 }
4786 return resultobj;
4787 fail:
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return NULL;
4793 }
4794
4795
4796 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj = 0;
4798 int arg1 ;
4799 bool arg2 = (bool) true ;
4800 wxString arg3 = (wxString) wxPyEmptyString ;
4801 wxString result;
4802 int val1 ;
4803 int ecode1 = 0 ;
4804 bool val2 ;
4805 int ecode2 = 0 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 PyObject * obj2 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4814 ecode1 = SWIG_AsVal_int(obj0, &val1);
4815 if (!SWIG_IsOK(ecode1)) {
4816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4817 }
4818 arg1 = static_cast< int >(val1);
4819 if (obj1) {
4820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4821 if (!SWIG_IsOK(ecode2)) {
4822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4823 }
4824 arg2 = static_cast< bool >(val2);
4825 }
4826 if (obj2) {
4827 {
4828 wxString* sptr = wxString_in_helper(obj2);
4829 if (sptr == NULL) SWIG_fail;
4830 arg3 = *sptr;
4831 delete sptr;
4832 }
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = wxGetStockLabel(arg1,arg2,arg3);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 #if wxUSE_UNICODE
4842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4843 #else
4844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4845 #endif
4846 }
4847 return resultobj;
4848 fail:
4849 return NULL;
4850 }
4851
4852
4853 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4854 PyObject *resultobj = 0;
4855
4856 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4857 {
4858 if (!wxPyCheckForApp()) SWIG_fail;
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 wxBell();
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4872 PyObject *resultobj = 0;
4873
4874 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4875 {
4876 if (!wxPyCheckForApp()) SWIG_fail;
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 wxEndBusyCursor();
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 resultobj = SWIG_Py_Void();
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 bool arg1 = (bool) true ;
4892 long result;
4893 bool val1 ;
4894 int ecode1 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "resetTimer", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4901 if (obj0) {
4902 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4903 if (!SWIG_IsOK(ecode1)) {
4904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4905 }
4906 arg1 = static_cast< bool >(val1);
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (long)wxGetElapsedTime(arg1);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_From_long(static_cast< long >(result));
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923 bool result;
4924
4925 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4926 {
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 result = (bool)wxIsBusy();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 {
4933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4934 }
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4942 PyObject *resultobj = 0;
4943 wxString result;
4944
4945 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = wxNow();
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 {
4953 #if wxUSE_UNICODE
4954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4955 #else
4956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4957 #endif
4958 }
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxString const &arg1_defvalue = wxPyEmptyString ;
4968 wxString *arg1 = (wxString *) &arg1_defvalue ;
4969 bool result;
4970 bool temp1 = false ;
4971 PyObject * obj0 = 0 ;
4972 char * kwnames[] = {
4973 (char *) "command", NULL
4974 };
4975
4976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4977 if (obj0) {
4978 {
4979 arg1 = wxString_in_helper(obj0);
4980 if (arg1 == NULL) SWIG_fail;
4981 temp1 = true;
4982 }
4983 }
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (bool)wxShell((wxString const &)*arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4992 }
4993 {
4994 if (temp1)
4995 delete arg1;
4996 }
4997 return resultobj;
4998 fail:
4999 {
5000 if (temp1)
5001 delete arg1;
5002 }
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009
5010 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 wxStartTimer();
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 int *arg1 = (int *) 0 ;
5027 int *arg2 = (int *) 0 ;
5028 int result;
5029 int temp1 ;
5030 int res1 = SWIG_TMPOBJ ;
5031 int temp2 ;
5032 int res2 = SWIG_TMPOBJ ;
5033
5034 arg1 = &temp1;
5035 arg2 = &temp2;
5036 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (int)wxGetOsVersion(arg1,arg2);
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_From_int(static_cast< int >(result));
5044 if (SWIG_IsTmpObj(res1)) {
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5046 } else {
5047 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5049 }
5050 if (SWIG_IsTmpObj(res2)) {
5051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5052 } else {
5053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5055 }
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 wxString result;
5065
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = wxGetOsDescription();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 {
5074 #if wxUSE_UNICODE
5075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5076 #else
5077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5078 #endif
5079 }
5080 return resultobj;
5081 fail:
5082 return NULL;
5083 }
5084
5085
5086 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5087 PyObject *resultobj = 0;
5088 wxMemorySize result;
5089
5090 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = wxGetFreeMemory();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5105 PyObject *resultobj = 0;
5106 wxShutdownFlags arg1 ;
5107 bool result;
5108 int val1 ;
5109 int ecode1 = 0 ;
5110 PyObject * obj0 = 0 ;
5111 char * kwnames[] = {
5112 (char *) "wFlags", NULL
5113 };
5114
5115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5116 ecode1 = SWIG_AsVal_int(obj0, &val1);
5117 if (!SWIG_IsOK(ecode1)) {
5118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5119 }
5120 arg1 = static_cast< wxShutdownFlags >(val1);
5121 {
5122 if (!wxPyCheckForApp()) SWIG_fail;
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (bool)wxShutdown(arg1);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 {
5129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5130 }
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5138 PyObject *resultobj = 0;
5139 int arg1 ;
5140 int val1 ;
5141 int ecode1 = 0 ;
5142 PyObject * obj0 = 0 ;
5143 char * kwnames[] = {
5144 (char *) "secs", NULL
5145 };
5146
5147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5148 ecode1 = SWIG_AsVal_int(obj0, &val1);
5149 if (!SWIG_IsOK(ecode1)) {
5150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5151 }
5152 arg1 = static_cast< int >(val1);
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 wxSleep(arg1);
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 resultobj = SWIG_Py_Void();
5160 return resultobj;
5161 fail:
5162 return NULL;
5163 }
5164
5165
5166 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5167 PyObject *resultobj = 0;
5168 unsigned long arg1 ;
5169 unsigned long val1 ;
5170 int ecode1 = 0 ;
5171 PyObject * obj0 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "milliseconds", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5177 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5178 if (!SWIG_IsOK(ecode1)) {
5179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5180 }
5181 arg1 = static_cast< unsigned long >(val1);
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 wxMilliSleep(arg1);
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj = 0;
5197 unsigned long arg1 ;
5198 unsigned long val1 ;
5199 int ecode1 = 0 ;
5200 PyObject * obj0 = 0 ;
5201 char * kwnames[] = {
5202 (char *) "microseconds", NULL
5203 };
5204
5205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5206 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5207 if (!SWIG_IsOK(ecode1)) {
5208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5209 }
5210 arg1 = static_cast< unsigned long >(val1);
5211 {
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 wxMicroSleep(arg1);
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_Py_Void();
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 bool arg1 ;
5227 bool val1 ;
5228 int ecode1 = 0 ;
5229 PyObject * obj0 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "enable", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5235 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5236 if (!SWIG_IsOK(ecode1)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5238 }
5239 arg1 = static_cast< bool >(val1);
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 wxEnableTopLevelWindows(arg1);
5243 wxPyEndAllowThreads(__tstate);
5244 if (PyErr_Occurred()) SWIG_fail;
5245 }
5246 resultobj = SWIG_Py_Void();
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5254 PyObject *resultobj = 0;
5255 wxString *arg1 = 0 ;
5256 wxString result;
5257 bool temp1 = false ;
5258 PyObject * obj0 = 0 ;
5259 char * kwnames[] = {
5260 (char *) "in", NULL
5261 };
5262
5263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5264 {
5265 arg1 = wxString_in_helper(obj0);
5266 if (arg1 == NULL) SWIG_fail;
5267 temp1 = true;
5268 }
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = wxStripMenuCodes((wxString const &)*arg1);
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 {
5276 #if wxUSE_UNICODE
5277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5278 #else
5279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5280 #endif
5281 }
5282 {
5283 if (temp1)
5284 delete arg1;
5285 }
5286 return resultobj;
5287 fail:
5288 {
5289 if (temp1)
5290 delete arg1;
5291 }
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxString result;
5299
5300 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5301 {
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 result = wxGetEmailAddress();
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 {
5308 #if wxUSE_UNICODE
5309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5310 #else
5311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5312 #endif
5313 }
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5321 PyObject *resultobj = 0;
5322 wxString result;
5323
5324 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5325 {
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 result = wxGetHostName();
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 #if wxUSE_UNICODE
5333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5334 #else
5335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5336 #endif
5337 }
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *resultobj = 0;
5346 wxString result;
5347
5348 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxGetFullHostName();
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *resultobj = 0;
5370 wxString result;
5371
5372 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5373 {
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = wxGetUserId();
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 #if wxUSE_UNICODE
5381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5382 #else
5383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5384 #endif
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetUserName();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetHomeDir();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 wxString const &arg1_defvalue = wxPyEmptyString ;
5443 wxString *arg1 = (wxString *) &arg1_defvalue ;
5444 wxString result;
5445 bool temp1 = false ;
5446 PyObject * obj0 = 0 ;
5447 char * kwnames[] = {
5448 (char *) "user", NULL
5449 };
5450
5451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5452 if (obj0) {
5453 {
5454 arg1 = wxString_in_helper(obj0);
5455 if (arg1 == NULL) SWIG_fail;
5456 temp1 = true;
5457 }
5458 }
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 result = wxGetUserHome((wxString const &)*arg1);
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 {
5466 #if wxUSE_UNICODE
5467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5468 #else
5469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5470 #endif
5471 }
5472 {
5473 if (temp1)
5474 delete arg1;
5475 }
5476 return resultobj;
5477 fail:
5478 {
5479 if (temp1)
5480 delete arg1;
5481 }
5482 return NULL;
5483 }
5484
5485
5486 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 PyObject *resultobj = 0;
5488 unsigned long result;
5489
5490 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (unsigned long)wxGetProcessId();
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506
5507 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 wxTrap();
5511 wxPyEndAllowThreads(__tstate);
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5524 wxString *arg1 = (wxString *) &arg1_defvalue ;
5525 wxString const &arg2_defvalue = wxPyEmptyString ;
5526 wxString *arg2 = (wxString *) &arg2_defvalue ;
5527 wxString const &arg3_defvalue = wxPyEmptyString ;
5528 wxString *arg3 = (wxString *) &arg3_defvalue ;
5529 wxString const &arg4_defvalue = wxPyEmptyString ;
5530 wxString *arg4 = (wxString *) &arg4_defvalue ;
5531 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5532 wxString *arg5 = (wxString *) &arg5_defvalue ;
5533 int arg6 = (int) 0 ;
5534 wxWindow *arg7 = (wxWindow *) NULL ;
5535 int arg8 = (int) -1 ;
5536 int arg9 = (int) -1 ;
5537 wxString result;
5538 bool temp1 = false ;
5539 bool temp2 = false ;
5540 bool temp3 = false ;
5541 bool temp4 = false ;
5542 bool temp5 = false ;
5543 int val6 ;
5544 int ecode6 = 0 ;
5545 void *argp7 = 0 ;
5546 int res7 = 0 ;
5547 int val8 ;
5548 int ecode8 = 0 ;
5549 int val9 ;
5550 int ecode9 = 0 ;
5551 PyObject * obj0 = 0 ;
5552 PyObject * obj1 = 0 ;
5553 PyObject * obj2 = 0 ;
5554 PyObject * obj3 = 0 ;
5555 PyObject * obj4 = 0 ;
5556 PyObject * obj5 = 0 ;
5557 PyObject * obj6 = 0 ;
5558 PyObject * obj7 = 0 ;
5559 PyObject * obj8 = 0 ;
5560 char * kwnames[] = {
5561 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5562 };
5563
5564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5565 if (obj0) {
5566 {
5567 arg1 = wxString_in_helper(obj0);
5568 if (arg1 == NULL) SWIG_fail;
5569 temp1 = true;
5570 }
5571 }
5572 if (obj1) {
5573 {
5574 arg2 = wxString_in_helper(obj1);
5575 if (arg2 == NULL) SWIG_fail;
5576 temp2 = true;
5577 }
5578 }
5579 if (obj2) {
5580 {
5581 arg3 = wxString_in_helper(obj2);
5582 if (arg3 == NULL) SWIG_fail;
5583 temp3 = true;
5584 }
5585 }
5586 if (obj3) {
5587 {
5588 arg4 = wxString_in_helper(obj3);
5589 if (arg4 == NULL) SWIG_fail;
5590 temp4 = true;
5591 }
5592 }
5593 if (obj4) {
5594 {
5595 arg5 = wxString_in_helper(obj4);
5596 if (arg5 == NULL) SWIG_fail;
5597 temp5 = true;
5598 }
5599 }
5600 if (obj5) {
5601 ecode6 = SWIG_AsVal_int(obj5, &val6);
5602 if (!SWIG_IsOK(ecode6)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5604 }
5605 arg6 = static_cast< int >(val6);
5606 }
5607 if (obj6) {
5608 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5609 if (!SWIG_IsOK(res7)) {
5610 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5611 }
5612 arg7 = reinterpret_cast< wxWindow * >(argp7);
5613 }
5614 if (obj7) {
5615 ecode8 = SWIG_AsVal_int(obj7, &val8);
5616 if (!SWIG_IsOK(ecode8)) {
5617 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5618 }
5619 arg8 = static_cast< int >(val8);
5620 }
5621 if (obj8) {
5622 ecode9 = SWIG_AsVal_int(obj8, &val9);
5623 if (!SWIG_IsOK(ecode9)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5625 }
5626 arg9 = static_cast< int >(val9);
5627 }
5628 {
5629 if (!wxPyCheckForApp()) SWIG_fail;
5630 PyThreadState* __tstate = wxPyBeginAllowThreads();
5631 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 {
5636 #if wxUSE_UNICODE
5637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5638 #else
5639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5640 #endif
5641 }
5642 {
5643 if (temp1)
5644 delete arg1;
5645 }
5646 {
5647 if (temp2)
5648 delete arg2;
5649 }
5650 {
5651 if (temp3)
5652 delete arg3;
5653 }
5654 {
5655 if (temp4)
5656 delete arg4;
5657 }
5658 {
5659 if (temp5)
5660 delete arg5;
5661 }
5662 return resultobj;
5663 fail:
5664 {
5665 if (temp1)
5666 delete arg1;
5667 }
5668 {
5669 if (temp2)
5670 delete arg2;
5671 }
5672 {
5673 if (temp3)
5674 delete arg3;
5675 }
5676 {
5677 if (temp4)
5678 delete arg4;
5679 }
5680 {
5681 if (temp5)
5682 delete arg5;
5683 }
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5689 PyObject *resultobj = 0;
5690 wxString *arg1 = 0 ;
5691 wxString *arg2 = 0 ;
5692 wxString const &arg3_defvalue = wxPyEmptyString ;
5693 wxString *arg3 = (wxString *) &arg3_defvalue ;
5694 wxWindow *arg4 = (wxWindow *) NULL ;
5695 wxString result;
5696 bool temp1 = false ;
5697 bool temp2 = false ;
5698 bool temp3 = false ;
5699 void *argp4 = 0 ;
5700 int res4 = 0 ;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 PyObject * obj2 = 0 ;
5704 PyObject * obj3 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5710 {
5711 arg1 = wxString_in_helper(obj0);
5712 if (arg1 == NULL) SWIG_fail;
5713 temp1 = true;
5714 }
5715 {
5716 arg2 = wxString_in_helper(obj1);
5717 if (arg2 == NULL) SWIG_fail;
5718 temp2 = true;
5719 }
5720 if (obj2) {
5721 {
5722 arg3 = wxString_in_helper(obj2);
5723 if (arg3 == NULL) SWIG_fail;
5724 temp3 = true;
5725 }
5726 }
5727 if (obj3) {
5728 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5729 if (!SWIG_IsOK(res4)) {
5730 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5731 }
5732 arg4 = reinterpret_cast< wxWindow * >(argp4);
5733 }
5734 {
5735 if (!wxPyCheckForApp()) SWIG_fail;
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 {
5742 #if wxUSE_UNICODE
5743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5744 #else
5745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5746 #endif
5747 }
5748 {
5749 if (temp1)
5750 delete arg1;
5751 }
5752 {
5753 if (temp2)
5754 delete arg2;
5755 }
5756 {
5757 if (temp3)
5758 delete arg3;
5759 }
5760 return resultobj;
5761 fail:
5762 {
5763 if (temp1)
5764 delete arg1;
5765 }
5766 {
5767 if (temp2)
5768 delete arg2;
5769 }
5770 {
5771 if (temp3)
5772 delete arg3;
5773 }
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5779 PyObject *resultobj = 0;
5780 wxString *arg1 = 0 ;
5781 wxString *arg2 = 0 ;
5782 wxString const &arg3_defvalue = wxPyEmptyString ;
5783 wxString *arg3 = (wxString *) &arg3_defvalue ;
5784 wxWindow *arg4 = (wxWindow *) NULL ;
5785 wxString result;
5786 bool temp1 = false ;
5787 bool temp2 = false ;
5788 bool temp3 = false ;
5789 void *argp4 = 0 ;
5790 int res4 = 0 ;
5791 PyObject * obj0 = 0 ;
5792 PyObject * obj1 = 0 ;
5793 PyObject * obj2 = 0 ;
5794 PyObject * obj3 = 0 ;
5795 char * kwnames[] = {
5796 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5797 };
5798
5799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5800 {
5801 arg1 = wxString_in_helper(obj0);
5802 if (arg1 == NULL) SWIG_fail;
5803 temp1 = true;
5804 }
5805 {
5806 arg2 = wxString_in_helper(obj1);
5807 if (arg2 == NULL) SWIG_fail;
5808 temp2 = true;
5809 }
5810 if (obj2) {
5811 {
5812 arg3 = wxString_in_helper(obj2);
5813 if (arg3 == NULL) SWIG_fail;
5814 temp3 = true;
5815 }
5816 }
5817 if (obj3) {
5818 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5819 if (!SWIG_IsOK(res4)) {
5820 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5821 }
5822 arg4 = reinterpret_cast< wxWindow * >(argp4);
5823 }
5824 {
5825 if (!wxPyCheckForApp()) SWIG_fail;
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 {
5832 #if wxUSE_UNICODE
5833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5834 #else
5835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5836 #endif
5837 }
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return resultobj;
5851 fail:
5852 {
5853 if (temp1)
5854 delete arg1;
5855 }
5856 {
5857 if (temp2)
5858 delete arg2;
5859 }
5860 {
5861 if (temp3)
5862 delete arg3;
5863 }
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5871 wxString *arg1 = (wxString *) &arg1_defvalue ;
5872 wxString const &arg2_defvalue = wxPyEmptyString ;
5873 wxString *arg2 = (wxString *) &arg2_defvalue ;
5874 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5875 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5876 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5877 wxWindow *arg5 = (wxWindow *) NULL ;
5878 wxString result;
5879 bool temp1 = false ;
5880 bool temp2 = false ;
5881 long val3 ;
5882 int ecode3 = 0 ;
5883 wxPoint temp4 ;
5884 void *argp5 = 0 ;
5885 int res5 = 0 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 PyObject * obj2 = 0 ;
5889 PyObject * obj3 = 0 ;
5890 PyObject * obj4 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5896 if (obj0) {
5897 {
5898 arg1 = wxString_in_helper(obj0);
5899 if (arg1 == NULL) SWIG_fail;
5900 temp1 = true;
5901 }
5902 }
5903 if (obj1) {
5904 {
5905 arg2 = wxString_in_helper(obj1);
5906 if (arg2 == NULL) SWIG_fail;
5907 temp2 = true;
5908 }
5909 }
5910 if (obj2) {
5911 ecode3 = SWIG_AsVal_long(obj2, &val3);
5912 if (!SWIG_IsOK(ecode3)) {
5913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5914 }
5915 arg3 = static_cast< long >(val3);
5916 }
5917 if (obj3) {
5918 {
5919 arg4 = &temp4;
5920 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5921 }
5922 }
5923 if (obj4) {
5924 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5925 if (!SWIG_IsOK(res5)) {
5926 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5927 }
5928 arg5 = reinterpret_cast< wxWindow * >(argp5);
5929 }
5930 {
5931 if (!wxPyCheckForApp()) SWIG_fail;
5932 PyThreadState* __tstate = wxPyBeginAllowThreads();
5933 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 #if wxUSE_UNICODE
5939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5940 #else
5941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5942 #endif
5943 }
5944 {
5945 if (temp1)
5946 delete arg1;
5947 }
5948 {
5949 if (temp2)
5950 delete arg2;
5951 }
5952 return resultobj;
5953 fail:
5954 {
5955 if (temp1)
5956 delete arg1;
5957 }
5958 {
5959 if (temp2)
5960 delete arg2;
5961 }
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxString *arg1 = 0 ;
5969 wxString const &arg2_defvalue = wxPyEmptyString ;
5970 wxString *arg2 = (wxString *) &arg2_defvalue ;
5971 wxString const &arg3_defvalue = wxPyEmptyString ;
5972 wxString *arg3 = (wxString *) &arg3_defvalue ;
5973 wxWindow *arg4 = (wxWindow *) NULL ;
5974 int arg5 = (int) -1 ;
5975 int arg6 = (int) -1 ;
5976 bool arg7 = (bool) true ;
5977 wxString result;
5978 bool temp1 = false ;
5979 bool temp2 = false ;
5980 bool temp3 = false ;
5981 void *argp4 = 0 ;
5982 int res4 = 0 ;
5983 int val5 ;
5984 int ecode5 = 0 ;
5985 int val6 ;
5986 int ecode6 = 0 ;
5987 bool val7 ;
5988 int ecode7 = 0 ;
5989 PyObject * obj0 = 0 ;
5990 PyObject * obj1 = 0 ;
5991 PyObject * obj2 = 0 ;
5992 PyObject * obj3 = 0 ;
5993 PyObject * obj4 = 0 ;
5994 PyObject * obj5 = 0 ;
5995 PyObject * obj6 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6001 {
6002 arg1 = wxString_in_helper(obj0);
6003 if (arg1 == NULL) SWIG_fail;
6004 temp1 = true;
6005 }
6006 if (obj1) {
6007 {
6008 arg2 = wxString_in_helper(obj1);
6009 if (arg2 == NULL) SWIG_fail;
6010 temp2 = true;
6011 }
6012 }
6013 if (obj2) {
6014 {
6015 arg3 = wxString_in_helper(obj2);
6016 if (arg3 == NULL) SWIG_fail;
6017 temp3 = true;
6018 }
6019 }
6020 if (obj3) {
6021 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6022 if (!SWIG_IsOK(res4)) {
6023 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6024 }
6025 arg4 = reinterpret_cast< wxWindow * >(argp4);
6026 }
6027 if (obj4) {
6028 ecode5 = SWIG_AsVal_int(obj4, &val5);
6029 if (!SWIG_IsOK(ecode5)) {
6030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6031 }
6032 arg5 = static_cast< int >(val5);
6033 }
6034 if (obj5) {
6035 ecode6 = SWIG_AsVal_int(obj5, &val6);
6036 if (!SWIG_IsOK(ecode6)) {
6037 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6038 }
6039 arg6 = static_cast< int >(val6);
6040 }
6041 if (obj6) {
6042 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6043 if (!SWIG_IsOK(ecode7)) {
6044 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6045 }
6046 arg7 = static_cast< bool >(val7);
6047 }
6048 {
6049 if (!wxPyCheckForApp()) SWIG_fail;
6050 PyThreadState* __tstate = wxPyBeginAllowThreads();
6051 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6052 wxPyEndAllowThreads(__tstate);
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 {
6056 #if wxUSE_UNICODE
6057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6058 #else
6059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6060 #endif
6061 }
6062 {
6063 if (temp1)
6064 delete arg1;
6065 }
6066 {
6067 if (temp2)
6068 delete arg2;
6069 }
6070 {
6071 if (temp3)
6072 delete arg3;
6073 }
6074 return resultobj;
6075 fail:
6076 {
6077 if (temp1)
6078 delete arg1;
6079 }
6080 {
6081 if (temp2)
6082 delete arg2;
6083 }
6084 {
6085 if (temp3)
6086 delete arg3;
6087 }
6088 return NULL;
6089 }
6090
6091
6092 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj = 0;
6094 wxString *arg1 = 0 ;
6095 wxString const &arg2_defvalue = wxPyEmptyString ;
6096 wxString *arg2 = (wxString *) &arg2_defvalue ;
6097 wxString const &arg3_defvalue = wxPyEmptyString ;
6098 wxString *arg3 = (wxString *) &arg3_defvalue ;
6099 wxWindow *arg4 = (wxWindow *) NULL ;
6100 wxString result;
6101 bool temp1 = false ;
6102 bool temp2 = false ;
6103 bool temp3 = false ;
6104 void *argp4 = 0 ;
6105 int res4 = 0 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 PyObject * obj2 = 0 ;
6109 PyObject * obj3 = 0 ;
6110 char * kwnames[] = {
6111 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6112 };
6113
6114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6115 {
6116 arg1 = wxString_in_helper(obj0);
6117 if (arg1 == NULL) SWIG_fail;
6118 temp1 = true;
6119 }
6120 if (obj1) {
6121 {
6122 arg2 = wxString_in_helper(obj1);
6123 if (arg2 == NULL) SWIG_fail;
6124 temp2 = true;
6125 }
6126 }
6127 if (obj2) {
6128 {
6129 arg3 = wxString_in_helper(obj2);
6130 if (arg3 == NULL) SWIG_fail;
6131 temp3 = true;
6132 }
6133 }
6134 if (obj3) {
6135 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6136 if (!SWIG_IsOK(res4)) {
6137 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6138 }
6139 arg4 = reinterpret_cast< wxWindow * >(argp4);
6140 }
6141 {
6142 if (!wxPyCheckForApp()) SWIG_fail;
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 {
6149 #if wxUSE_UNICODE
6150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6151 #else
6152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6153 #endif
6154 }
6155 {
6156 if (temp1)
6157 delete arg1;
6158 }
6159 {
6160 if (temp2)
6161 delete arg2;
6162 }
6163 {
6164 if (temp3)
6165 delete arg3;
6166 }
6167 return resultobj;
6168 fail:
6169 {
6170 if (temp1)
6171 delete arg1;
6172 }
6173 {
6174 if (temp2)
6175 delete arg2;
6176 }
6177 {
6178 if (temp3)
6179 delete arg3;
6180 }
6181 return NULL;
6182 }
6183
6184
6185 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj = 0;
6187 wxString *arg1 = 0 ;
6188 wxString *arg2 = 0 ;
6189 int arg3 ;
6190 wxString *arg4 = (wxString *) 0 ;
6191 wxWindow *arg5 = (wxWindow *) NULL ;
6192 int arg6 = (int) -1 ;
6193 int arg7 = (int) -1 ;
6194 bool arg8 = (bool) true ;
6195 int arg9 = (int) 150 ;
6196 int arg10 = (int) 200 ;
6197 wxString result;
6198 bool temp1 = false ;
6199 bool temp2 = false ;
6200 void *argp5 = 0 ;
6201 int res5 = 0 ;
6202 int val6 ;
6203 int ecode6 = 0 ;
6204 int val7 ;
6205 int ecode7 = 0 ;
6206 bool val8 ;
6207 int ecode8 = 0 ;
6208 int val9 ;
6209 int ecode9 = 0 ;
6210 int val10 ;
6211 int ecode10 = 0 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 PyObject * obj2 = 0 ;
6215 PyObject * obj3 = 0 ;
6216 PyObject * obj4 = 0 ;
6217 PyObject * obj5 = 0 ;
6218 PyObject * obj6 = 0 ;
6219 PyObject * obj7 = 0 ;
6220 PyObject * obj8 = 0 ;
6221 char * kwnames[] = {
6222 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6223 };
6224
6225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6226 {
6227 arg1 = wxString_in_helper(obj0);
6228 if (arg1 == NULL) SWIG_fail;
6229 temp1 = true;
6230 }
6231 {
6232 arg2 = wxString_in_helper(obj1);
6233 if (arg2 == NULL) SWIG_fail;
6234 temp2 = true;
6235 }
6236 {
6237 arg3 = PyList_Size(obj2);
6238 arg4 = wxString_LIST_helper(obj2);
6239 if (arg4 == NULL) SWIG_fail;
6240 }
6241 if (obj3) {
6242 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6243 if (!SWIG_IsOK(res5)) {
6244 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6245 }
6246 arg5 = reinterpret_cast< wxWindow * >(argp5);
6247 }
6248 if (obj4) {
6249 ecode6 = SWIG_AsVal_int(obj4, &val6);
6250 if (!SWIG_IsOK(ecode6)) {
6251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6252 }
6253 arg6 = static_cast< int >(val6);
6254 }
6255 if (obj5) {
6256 ecode7 = SWIG_AsVal_int(obj5, &val7);
6257 if (!SWIG_IsOK(ecode7)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6259 }
6260 arg7 = static_cast< int >(val7);
6261 }
6262 if (obj6) {
6263 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6264 if (!SWIG_IsOK(ecode8)) {
6265 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6266 }
6267 arg8 = static_cast< bool >(val8);
6268 }
6269 if (obj7) {
6270 ecode9 = SWIG_AsVal_int(obj7, &val9);
6271 if (!SWIG_IsOK(ecode9)) {
6272 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6273 }
6274 arg9 = static_cast< int >(val9);
6275 }
6276 if (obj8) {
6277 ecode10 = SWIG_AsVal_int(obj8, &val10);
6278 if (!SWIG_IsOK(ecode10)) {
6279 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6280 }
6281 arg10 = static_cast< int >(val10);
6282 }
6283 {
6284 if (!wxPyCheckForApp()) SWIG_fail;
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 {
6291 #if wxUSE_UNICODE
6292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6293 #else
6294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6295 #endif
6296 }
6297 {
6298 if (temp1)
6299 delete arg1;
6300 }
6301 {
6302 if (temp2)
6303 delete arg2;
6304 }
6305 {
6306 if (arg4) delete [] arg4;
6307 }
6308 return resultobj;
6309 fail:
6310 {
6311 if (temp1)
6312 delete arg1;
6313 }
6314 {
6315 if (temp2)
6316 delete arg2;
6317 }
6318 {
6319 if (arg4) delete [] arg4;
6320 }
6321 return NULL;
6322 }
6323
6324
6325 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = 0;
6327 wxString *arg1 = 0 ;
6328 wxString *arg2 = 0 ;
6329 int arg3 ;
6330 wxString *arg4 = (wxString *) 0 ;
6331 wxWindow *arg5 = (wxWindow *) NULL ;
6332 int arg6 = (int) -1 ;
6333 int arg7 = (int) -1 ;
6334 bool arg8 = (bool) true ;
6335 int arg9 = (int) 150 ;
6336 int arg10 = (int) 200 ;
6337 int result;
6338 bool temp1 = false ;
6339 bool temp2 = false ;
6340 void *argp5 = 0 ;
6341 int res5 = 0 ;
6342 int val6 ;
6343 int ecode6 = 0 ;
6344 int val7 ;
6345 int ecode7 = 0 ;
6346 bool val8 ;
6347 int ecode8 = 0 ;
6348 int val9 ;
6349 int ecode9 = 0 ;
6350 int val10 ;
6351 int ecode10 = 0 ;
6352 PyObject * obj0 = 0 ;
6353 PyObject * obj1 = 0 ;
6354 PyObject * obj2 = 0 ;
6355 PyObject * obj3 = 0 ;
6356 PyObject * obj4 = 0 ;
6357 PyObject * obj5 = 0 ;
6358 PyObject * obj6 = 0 ;
6359 PyObject * obj7 = 0 ;
6360 PyObject * obj8 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6366 {
6367 arg1 = wxString_in_helper(obj0);
6368 if (arg1 == NULL) SWIG_fail;
6369 temp1 = true;
6370 }
6371 {
6372 arg2 = wxString_in_helper(obj1);
6373 if (arg2 == NULL) SWIG_fail;
6374 temp2 = true;
6375 }
6376 {
6377 arg3 = PyList_Size(obj2);
6378 arg4 = wxString_LIST_helper(obj2);
6379 if (arg4 == NULL) SWIG_fail;
6380 }
6381 if (obj3) {
6382 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6383 if (!SWIG_IsOK(res5)) {
6384 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6385 }
6386 arg5 = reinterpret_cast< wxWindow * >(argp5);
6387 }
6388 if (obj4) {
6389 ecode6 = SWIG_AsVal_int(obj4, &val6);
6390 if (!SWIG_IsOK(ecode6)) {
6391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6392 }
6393 arg6 = static_cast< int >(val6);
6394 }
6395 if (obj5) {
6396 ecode7 = SWIG_AsVal_int(obj5, &val7);
6397 if (!SWIG_IsOK(ecode7)) {
6398 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6399 }
6400 arg7 = static_cast< int >(val7);
6401 }
6402 if (obj6) {
6403 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6404 if (!SWIG_IsOK(ecode8)) {
6405 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6406 }
6407 arg8 = static_cast< bool >(val8);
6408 }
6409 if (obj7) {
6410 ecode9 = SWIG_AsVal_int(obj7, &val9);
6411 if (!SWIG_IsOK(ecode9)) {
6412 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6413 }
6414 arg9 = static_cast< int >(val9);
6415 }
6416 if (obj8) {
6417 ecode10 = SWIG_AsVal_int(obj8, &val10);
6418 if (!SWIG_IsOK(ecode10)) {
6419 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6420 }
6421 arg10 = static_cast< int >(val10);
6422 }
6423 {
6424 if (!wxPyCheckForApp()) SWIG_fail;
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 {
6432 if (temp1)
6433 delete arg1;
6434 }
6435 {
6436 if (temp2)
6437 delete arg2;
6438 }
6439 {
6440 if (arg4) delete [] arg4;
6441 }
6442 return resultobj;
6443 fail:
6444 {
6445 if (temp1)
6446 delete arg1;
6447 }
6448 {
6449 if (temp2)
6450 delete arg2;
6451 }
6452 {
6453 if (arg4) delete [] arg4;
6454 }
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj = 0;
6461 wxString *arg1 = 0 ;
6462 wxString const &arg2_defvalue = wxPyEmptyString ;
6463 wxString *arg2 = (wxString *) &arg2_defvalue ;
6464 int arg3 = (int) wxOK|wxCENTRE ;
6465 wxWindow *arg4 = (wxWindow *) NULL ;
6466 int arg5 = (int) -1 ;
6467 int arg6 = (int) -1 ;
6468 int result;
6469 bool temp1 = false ;
6470 bool temp2 = false ;
6471 int val3 ;
6472 int ecode3 = 0 ;
6473 void *argp4 = 0 ;
6474 int res4 = 0 ;
6475 int val5 ;
6476 int ecode5 = 0 ;
6477 int val6 ;
6478 int ecode6 = 0 ;
6479 PyObject * obj0 = 0 ;
6480 PyObject * obj1 = 0 ;
6481 PyObject * obj2 = 0 ;
6482 PyObject * obj3 = 0 ;
6483 PyObject * obj4 = 0 ;
6484 PyObject * obj5 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6490 {
6491 arg1 = wxString_in_helper(obj0);
6492 if (arg1 == NULL) SWIG_fail;
6493 temp1 = true;
6494 }
6495 if (obj1) {
6496 {
6497 arg2 = wxString_in_helper(obj1);
6498 if (arg2 == NULL) SWIG_fail;
6499 temp2 = true;
6500 }
6501 }
6502 if (obj2) {
6503 ecode3 = SWIG_AsVal_int(obj2, &val3);
6504 if (!SWIG_IsOK(ecode3)) {
6505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6506 }
6507 arg3 = static_cast< int >(val3);
6508 }
6509 if (obj3) {
6510 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6511 if (!SWIG_IsOK(res4)) {
6512 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6513 }
6514 arg4 = reinterpret_cast< wxWindow * >(argp4);
6515 }
6516 if (obj4) {
6517 ecode5 = SWIG_AsVal_int(obj4, &val5);
6518 if (!SWIG_IsOK(ecode5)) {
6519 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6520 }
6521 arg5 = static_cast< int >(val5);
6522 }
6523 if (obj5) {
6524 ecode6 = SWIG_AsVal_int(obj5, &val6);
6525 if (!SWIG_IsOK(ecode6)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6527 }
6528 arg6 = static_cast< int >(val6);
6529 }
6530 {
6531 if (!wxPyCheckForApp()) SWIG_fail;
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 resultobj = SWIG_From_int(static_cast< int >(result));
6538 {
6539 if (temp1)
6540 delete arg1;
6541 }
6542 {
6543 if (temp2)
6544 delete arg2;
6545 }
6546 return resultobj;
6547 fail:
6548 {
6549 if (temp1)
6550 delete arg1;
6551 }
6552 {
6553 if (temp2)
6554 delete arg2;
6555 }
6556 return NULL;
6557 }
6558
6559
6560 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6561 PyObject *resultobj = 0;
6562 bool result;
6563
6564 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6565 {
6566 if (!wxPyCheckForApp()) SWIG_fail;
6567 PyThreadState* __tstate = wxPyBeginAllowThreads();
6568 result = (bool)wxColourDisplay();
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 {
6573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6574 }
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6582 PyObject *resultobj = 0;
6583 int result;
6584
6585 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6586 {
6587 if (!wxPyCheckForApp()) SWIG_fail;
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 result = (int)wxDisplayDepth();
6590 wxPyEndAllowThreads(__tstate);
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6601 PyObject *resultobj = 0;
6602 int result;
6603
6604 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6605 {
6606 if (!wxPyCheckForApp()) SWIG_fail;
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = (int)wxGetDisplayDepth();
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_From_int(static_cast< int >(result));
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6620 PyObject *resultobj = 0;
6621 int *arg1 = (int *) 0 ;
6622 int *arg2 = (int *) 0 ;
6623 int temp1 ;
6624 int res1 = SWIG_TMPOBJ ;
6625 int temp2 ;
6626 int res2 = SWIG_TMPOBJ ;
6627
6628 arg1 = &temp1;
6629 arg2 = &temp2;
6630 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6631 {
6632 if (!wxPyCheckForApp()) SWIG_fail;
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 wxDisplaySize(arg1,arg2);
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 resultobj = SWIG_Py_Void();
6639 if (SWIG_IsTmpObj(res1)) {
6640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6641 } else {
6642 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6644 }
6645 if (SWIG_IsTmpObj(res2)) {
6646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6647 } else {
6648 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6650 }
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6658 PyObject *resultobj = 0;
6659 wxSize result;
6660
6661 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6662 {
6663 if (!wxPyCheckForApp()) SWIG_fail;
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 result = wxGetDisplaySize();
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6677 PyObject *resultobj = 0;
6678 int *arg1 = (int *) 0 ;
6679 int *arg2 = (int *) 0 ;
6680 int temp1 ;
6681 int res1 = SWIG_TMPOBJ ;
6682 int temp2 ;
6683 int res2 = SWIG_TMPOBJ ;
6684
6685 arg1 = &temp1;
6686 arg2 = &temp2;
6687 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6688 {
6689 if (!wxPyCheckForApp()) SWIG_fail;
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 wxDisplaySizeMM(arg1,arg2);
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_Py_Void();
6696 if (SWIG_IsTmpObj(res1)) {
6697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6698 } else {
6699 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6701 }
6702 if (SWIG_IsTmpObj(res2)) {
6703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6704 } else {
6705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6707 }
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6715 PyObject *resultobj = 0;
6716 wxSize result;
6717
6718 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6719 {
6720 if (!wxPyCheckForApp()) SWIG_fail;
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 result = wxGetDisplaySizeMM();
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 int *arg1 = (int *) 0 ;
6736 int *arg2 = (int *) 0 ;
6737 int *arg3 = (int *) 0 ;
6738 int *arg4 = (int *) 0 ;
6739 int temp1 ;
6740 int res1 = SWIG_TMPOBJ ;
6741 int temp2 ;
6742 int res2 = SWIG_TMPOBJ ;
6743 int temp3 ;
6744 int res3 = SWIG_TMPOBJ ;
6745 int temp4 ;
6746 int res4 = SWIG_TMPOBJ ;
6747
6748 arg1 = &temp1;
6749 arg2 = &temp2;
6750 arg3 = &temp3;
6751 arg4 = &temp4;
6752 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6753 {
6754 if (!wxPyCheckForApp()) SWIG_fail;
6755 PyThreadState* __tstate = wxPyBeginAllowThreads();
6756 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6757 wxPyEndAllowThreads(__tstate);
6758 if (PyErr_Occurred()) SWIG_fail;
6759 }
6760 resultobj = SWIG_Py_Void();
6761 if (SWIG_IsTmpObj(res1)) {
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6763 } else {
6764 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6766 }
6767 if (SWIG_IsTmpObj(res2)) {
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6769 } else {
6770 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6772 }
6773 if (SWIG_IsTmpObj(res3)) {
6774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6775 } else {
6776 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6778 }
6779 if (SWIG_IsTmpObj(res4)) {
6780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6781 } else {
6782 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 wxRect result;
6794
6795 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6796 {
6797 if (!wxPyCheckForApp()) SWIG_fail;
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = wxGetClientDisplayRect();
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = 0;
6812 wxCursor *arg1 = 0 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 PyObject * obj0 = 0 ;
6816 char * kwnames[] = {
6817 (char *) "cursor", NULL
6818 };
6819
6820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6821 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6822 if (!SWIG_IsOK(res1)) {
6823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6824 }
6825 if (!argp1) {
6826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6827 }
6828 arg1 = reinterpret_cast< wxCursor * >(argp1);
6829 {
6830 if (!wxPyCheckForApp()) SWIG_fail;
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 wxSetCursor(*arg1);
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 return resultobj;
6838 fail:
6839 return NULL;
6840 }
6841
6842
6843 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6844 PyObject *resultobj = 0;
6845 void *result = 0 ;
6846
6847 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6848 {
6849 if (!wxPyCheckForApp()) SWIG_fail;
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (void *)wxGetXDisplay();
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = 0;
6864 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6865 void *argp1 = 0 ;
6866 int res1 = 0 ;
6867 PyObject * obj0 = 0 ;
6868 char * kwnames[] = {
6869 (char *) "cursor", NULL
6870 };
6871
6872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6873 if (obj0) {
6874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6877 }
6878 arg1 = reinterpret_cast< wxCursor * >(argp1);
6879 }
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 wxBeginBusyCursor(arg1);
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_Py_Void();
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 wxPoint result;
6897
6898 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = wxGetMousePosition();
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6914 PyObject *resultobj = 0;
6915 wxWindow *result = 0 ;
6916
6917 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6918 {
6919 if (!wxPyCheckForApp()) SWIG_fail;
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = (wxWindow *)FindWindowAtPointer();
6922 wxPyEndAllowThreads(__tstate);
6923 if (PyErr_Occurred()) SWIG_fail;
6924 }
6925 {
6926 resultobj = wxPyMake_wxObject(result, 0);
6927 }
6928 return resultobj;
6929 fail:
6930 return NULL;
6931 }
6932
6933
6934 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6935 PyObject *resultobj = 0;
6936 wxWindow *result = 0 ;
6937
6938 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6939 {
6940 if (!wxPyCheckForApp()) SWIG_fail;
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 result = (wxWindow *)wxGetActiveWindow();
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 {
6947 resultobj = wxPyMake_wxObject(result, 0);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj = 0;
6957 wxPoint *arg1 = 0 ;
6958 wxWindow *result = 0 ;
6959 wxPoint temp1 ;
6960 PyObject * obj0 = 0 ;
6961 char * kwnames[] = {
6962 (char *) "pt", NULL
6963 };
6964
6965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6966 {
6967 arg1 = &temp1;
6968 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6969 }
6970 {
6971 if (!wxPyCheckForApp()) SWIG_fail;
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 {
6978 resultobj = wxPyMake_wxObject(result, 0);
6979 }
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6987 PyObject *resultobj = 0;
6988 wxPoint *arg1 = 0 ;
6989 wxWindow *result = 0 ;
6990 wxPoint temp1 ;
6991 PyObject * obj0 = 0 ;
6992 char * kwnames[] = {
6993 (char *) "pt", NULL
6994 };
6995
6996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6997 {
6998 arg1 = &temp1;
6999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7000 }
7001 {
7002 if (!wxPyCheckForApp()) SWIG_fail;
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 {
7009 resultobj = wxPyMake_wxObject(result, 0);
7010 }
7011 return resultobj;
7012 fail:
7013 return NULL;
7014 }
7015
7016
7017 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj = 0;
7019 wxWindow *arg1 = (wxWindow *) 0 ;
7020 wxWindow *result = 0 ;
7021 void *argp1 = 0 ;
7022 int res1 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "win", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7032 }
7033 arg1 = reinterpret_cast< wxWindow * >(argp1);
7034 {
7035 if (!wxPyCheckForApp()) SWIG_fail;
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 result = (wxWindow *)wxGetTopLevelParent(arg1);
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 {
7042 resultobj = wxPyMake_wxObject(result, 0);
7043 }
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj = 0;
7052 wxString *arg1 = 0 ;
7053 bool result;
7054 bool temp1 = false ;
7055 PyObject * obj0 = 0 ;
7056 char * kwnames[] = {
7057 (char *) "url", NULL
7058 };
7059
7060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7061 {
7062 arg1 = wxString_in_helper(obj0);
7063 if (arg1 == NULL) SWIG_fail;
7064 temp1 = true;
7065 }
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 {
7073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7074 }
7075 {
7076 if (temp1)
7077 delete arg1;
7078 }
7079 return resultobj;
7080 fail:
7081 {
7082 if (temp1)
7083 delete arg1;
7084 }
7085 return NULL;
7086 }
7087
7088
7089 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj = 0;
7091 wxKeyCode arg1 ;
7092 bool result;
7093 int val1 ;
7094 int ecode1 = 0 ;
7095 PyObject * obj0 = 0 ;
7096 char * kwnames[] = {
7097 (char *) "key", NULL
7098 };
7099
7100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7101 ecode1 = SWIG_AsVal_int(obj0, &val1);
7102 if (!SWIG_IsOK(ecode1)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7104 }
7105 arg1 = static_cast< wxKeyCode >(val1);
7106 {
7107 if (!wxPyCheckForApp()) SWIG_fail;
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (bool)wxGetKeyState(arg1);
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 {
7114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7115 }
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7123 PyObject *resultobj = 0;
7124 wxMouseState *result = 0 ;
7125
7126 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 result = (wxMouseState *)new wxMouseState();
7130 wxPyEndAllowThreads(__tstate);
7131 if (PyErr_Occurred()) SWIG_fail;
7132 }
7133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7141 PyObject *resultobj = 0;
7142 wxMouseState *arg1 = (wxMouseState *) 0 ;
7143 void *argp1 = 0 ;
7144 int res1 = 0 ;
7145 PyObject *swig_obj[1] ;
7146
7147 if (!args) SWIG_fail;
7148 swig_obj[0] = args;
7149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7150 if (!SWIG_IsOK(res1)) {
7151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7152 }
7153 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7154 {
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 delete arg1;
7157
7158 wxPyEndAllowThreads(__tstate);
7159 if (PyErr_Occurred()) SWIG_fail;
7160 }
7161 resultobj = SWIG_Py_Void();
7162 return resultobj;
7163 fail:
7164 return NULL;
7165 }
7166
7167
7168 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7169 PyObject *resultobj = 0;
7170 wxMouseState *arg1 = (wxMouseState *) 0 ;
7171 int result;
7172 void *argp1 = 0 ;
7173 int res1 = 0 ;
7174 PyObject *swig_obj[1] ;
7175
7176 if (!args) SWIG_fail;
7177 swig_obj[0] = args;
7178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7181 }
7182 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 result = (int)(arg1)->GetX();
7186 wxPyEndAllowThreads(__tstate);
7187 if (PyErr_Occurred()) SWIG_fail;
7188 }
7189 resultobj = SWIG_From_int(static_cast< int >(result));
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7197 PyObject *resultobj = 0;
7198 wxMouseState *arg1 = (wxMouseState *) 0 ;
7199 int result;
7200 void *argp1 = 0 ;
7201 int res1 = 0 ;
7202 PyObject *swig_obj[1] ;
7203
7204 if (!args) SWIG_fail;
7205 swig_obj[0] = args;
7206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7207 if (!SWIG_IsOK(res1)) {
7208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7209 }
7210 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7211 {
7212 PyThreadState* __tstate = wxPyBeginAllowThreads();
7213 result = (int)(arg1)->GetY();
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_From_int(static_cast< int >(result));
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7225 PyObject *resultobj = 0;
7226 wxMouseState *arg1 = (wxMouseState *) 0 ;
7227 bool result;
7228 void *argp1 = 0 ;
7229 int res1 = 0 ;
7230 PyObject *swig_obj[1] ;
7231
7232 if (!args) SWIG_fail;
7233 swig_obj[0] = args;
7234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7237 }
7238 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (bool)(arg1)->LeftDown();
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 {
7246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7247 }
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7255 PyObject *resultobj = 0;
7256 wxMouseState *arg1 = (wxMouseState *) 0 ;
7257 bool result;
7258 void *argp1 = 0 ;
7259 int res1 = 0 ;
7260 PyObject *swig_obj[1] ;
7261
7262 if (!args) SWIG_fail;
7263 swig_obj[0] = args;
7264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7265 if (!SWIG_IsOK(res1)) {
7266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7267 }
7268 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7269 {
7270 PyThreadState* __tstate = wxPyBeginAllowThreads();
7271 result = (bool)(arg1)->MiddleDown();
7272 wxPyEndAllowThreads(__tstate);
7273 if (PyErr_Occurred()) SWIG_fail;
7274 }
7275 {
7276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7277 }
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7285 PyObject *resultobj = 0;
7286 wxMouseState *arg1 = (wxMouseState *) 0 ;
7287 bool result;
7288 void *argp1 = 0 ;
7289 int res1 = 0 ;
7290 PyObject *swig_obj[1] ;
7291
7292 if (!args) SWIG_fail;
7293 swig_obj[0] = args;
7294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7297 }
7298 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7299 {
7300 PyThreadState* __tstate = wxPyBeginAllowThreads();
7301 result = (bool)(arg1)->RightDown();
7302 wxPyEndAllowThreads(__tstate);
7303 if (PyErr_Occurred()) SWIG_fail;
7304 }
7305 {
7306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7307 }
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7315 PyObject *resultobj = 0;
7316 wxMouseState *arg1 = (wxMouseState *) 0 ;
7317 bool result;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 PyObject *swig_obj[1] ;
7321
7322 if (!args) SWIG_fail;
7323 swig_obj[0] = args;
7324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7325 if (!SWIG_IsOK(res1)) {
7326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7327 }
7328 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 result = (bool)(arg1)->ControlDown();
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 {
7336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7337 }
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7345 PyObject *resultobj = 0;
7346 wxMouseState *arg1 = (wxMouseState *) 0 ;
7347 bool result;
7348 void *argp1 = 0 ;
7349 int res1 = 0 ;
7350 PyObject *swig_obj[1] ;
7351
7352 if (!args) SWIG_fail;
7353 swig_obj[0] = args;
7354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7355 if (!SWIG_IsOK(res1)) {
7356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7357 }
7358 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7359 {
7360 PyThreadState* __tstate = wxPyBeginAllowThreads();
7361 result = (bool)(arg1)->ShiftDown();
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 {
7366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxMouseState *arg1 = (wxMouseState *) 0 ;
7377 bool result;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject *swig_obj[1] ;
7381
7382 if (!args) SWIG_fail;
7383 swig_obj[0] = args;
7384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7387 }
7388 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 result = (bool)(arg1)->AltDown();
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 {
7396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7397 }
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7405 PyObject *resultobj = 0;
7406 wxMouseState *arg1 = (wxMouseState *) 0 ;
7407 bool result;
7408 void *argp1 = 0 ;
7409 int res1 = 0 ;
7410 PyObject *swig_obj[1] ;
7411
7412 if (!args) SWIG_fail;
7413 swig_obj[0] = args;
7414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7415 if (!SWIG_IsOK(res1)) {
7416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7417 }
7418 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 result = (bool)(arg1)->MetaDown();
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 {
7426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7427 }
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->CmdDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 int arg2 ;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 int val2 ;
7471 int ecode2 = 0 ;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "x", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7482 }
7483 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7484 ecode2 = SWIG_AsVal_int(obj1, &val2);
7485 if (!SWIG_IsOK(ecode2)) {
7486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7487 }
7488 arg2 = static_cast< int >(val2);
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 (arg1)->SetX(arg2);
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 resultobj = SWIG_Py_Void();
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj = 0;
7504 wxMouseState *arg1 = (wxMouseState *) 0 ;
7505 int arg2 ;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 int val2 ;
7509 int ecode2 = 0 ;
7510 PyObject * obj0 = 0 ;
7511 PyObject * obj1 = 0 ;
7512 char * kwnames[] = {
7513 (char *) "self",(char *) "y", NULL
7514 };
7515
7516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7518 if (!SWIG_IsOK(res1)) {
7519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7520 }
7521 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7522 ecode2 = SWIG_AsVal_int(obj1, &val2);
7523 if (!SWIG_IsOK(ecode2)) {
7524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7525 }
7526 arg2 = static_cast< int >(val2);
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 (arg1)->SetY(arg2);
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 resultobj = SWIG_Py_Void();
7534 return resultobj;
7535 fail:
7536 return NULL;
7537 }
7538
7539
7540 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7541 PyObject *resultobj = 0;
7542 wxMouseState *arg1 = (wxMouseState *) 0 ;
7543 bool arg2 ;
7544 void *argp1 = 0 ;
7545 int res1 = 0 ;
7546 bool val2 ;
7547 int ecode2 = 0 ;
7548 PyObject * obj0 = 0 ;
7549 PyObject * obj1 = 0 ;
7550 char * kwnames[] = {
7551 (char *) "self",(char *) "down", NULL
7552 };
7553
7554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7556 if (!SWIG_IsOK(res1)) {
7557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7558 }
7559 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7561 if (!SWIG_IsOK(ecode2)) {
7562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7563 }
7564 arg2 = static_cast< bool >(val2);
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 (arg1)->SetLeftDown(arg2);
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 resultobj = SWIG_Py_Void();
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxMouseState *arg1 = (wxMouseState *) 0 ;
7581 bool arg2 ;
7582 void *argp1 = 0 ;
7583 int res1 = 0 ;
7584 bool val2 ;
7585 int ecode2 = 0 ;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 char * kwnames[] = {
7589 (char *) "self",(char *) "down", NULL
7590 };
7591
7592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7594 if (!SWIG_IsOK(res1)) {
7595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7596 }
7597 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7599 if (!SWIG_IsOK(ecode2)) {
7600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7601 }
7602 arg2 = static_cast< bool >(val2);
7603 {
7604 PyThreadState* __tstate = wxPyBeginAllowThreads();
7605 (arg1)->SetMiddleDown(arg2);
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 resultobj = SWIG_Py_Void();
7610 return resultobj;
7611 fail:
7612 return NULL;
7613 }
7614
7615
7616 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7617 PyObject *resultobj = 0;
7618 wxMouseState *arg1 = (wxMouseState *) 0 ;
7619 bool arg2 ;
7620 void *argp1 = 0 ;
7621 int res1 = 0 ;
7622 bool val2 ;
7623 int ecode2 = 0 ;
7624 PyObject * obj0 = 0 ;
7625 PyObject * obj1 = 0 ;
7626 char * kwnames[] = {
7627 (char *) "self",(char *) "down", NULL
7628 };
7629
7630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7632 if (!SWIG_IsOK(res1)) {
7633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7634 }
7635 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7637 if (!SWIG_IsOK(ecode2)) {
7638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7639 }
7640 arg2 = static_cast< bool >(val2);
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 (arg1)->SetRightDown(arg2);
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 resultobj = SWIG_Py_Void();
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj = 0;
7656 wxMouseState *arg1 = (wxMouseState *) 0 ;
7657 bool arg2 ;
7658 void *argp1 = 0 ;
7659 int res1 = 0 ;
7660 bool val2 ;
7661 int ecode2 = 0 ;
7662 PyObject * obj0 = 0 ;
7663 PyObject * obj1 = 0 ;
7664 char * kwnames[] = {
7665 (char *) "self",(char *) "down", NULL
7666 };
7667
7668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7670 if (!SWIG_IsOK(res1)) {
7671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7672 }
7673 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7674 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7675 if (!SWIG_IsOK(ecode2)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7677 }
7678 arg2 = static_cast< bool >(val2);
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 (arg1)->SetControlDown(arg2);
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 resultobj = SWIG_Py_Void();
7686 return resultobj;
7687 fail:
7688 return NULL;
7689 }
7690
7691
7692 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7693 PyObject *resultobj = 0;
7694 wxMouseState *arg1 = (wxMouseState *) 0 ;
7695 bool arg2 ;
7696 void *argp1 = 0 ;
7697 int res1 = 0 ;
7698 bool val2 ;
7699 int ecode2 = 0 ;
7700 PyObject * obj0 = 0 ;
7701 PyObject * obj1 = 0 ;
7702 char * kwnames[] = {
7703 (char *) "self",(char *) "down", NULL
7704 };
7705
7706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7708 if (!SWIG_IsOK(res1)) {
7709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7710 }
7711 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7713 if (!SWIG_IsOK(ecode2)) {
7714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7715 }
7716 arg2 = static_cast< bool >(val2);
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 (arg1)->SetShiftDown(arg2);
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 resultobj = SWIG_Py_Void();
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj = 0;
7732 wxMouseState *arg1 = (wxMouseState *) 0 ;
7733 bool arg2 ;
7734 void *argp1 = 0 ;
7735 int res1 = 0 ;
7736 bool val2 ;
7737 int ecode2 = 0 ;
7738 PyObject * obj0 = 0 ;
7739 PyObject * obj1 = 0 ;
7740 char * kwnames[] = {
7741 (char *) "self",(char *) "down", NULL
7742 };
7743
7744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7748 }
7749 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7750 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7751 if (!SWIG_IsOK(ecode2)) {
7752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7753 }
7754 arg2 = static_cast< bool >(val2);
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 (arg1)->SetAltDown(arg2);
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 resultobj = SWIG_Py_Void();
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxMouseState *arg1 = (wxMouseState *) 0 ;
7771 bool arg2 ;
7772 void *argp1 = 0 ;
7773 int res1 = 0 ;
7774 bool val2 ;
7775 int ecode2 = 0 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "down", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7786 }
7787 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7789 if (!SWIG_IsOK(ecode2)) {
7790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7791 }
7792 arg2 = static_cast< bool >(val2);
7793 {
7794 PyThreadState* __tstate = wxPyBeginAllowThreads();
7795 (arg1)->SetMetaDown(arg2);
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 resultobj = SWIG_Py_Void();
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7807 PyObject *obj;
7808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7809 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7810 return SWIG_Py_Void();
7811 }
7812
7813 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7814 return SWIG_Python_InitShadowInstance(args);
7815 }
7816
7817 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7818 PyObject *resultobj = 0;
7819 wxMouseState result;
7820
7821 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = wxGetMouseState();
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7836 PyObject *resultobj = 0;
7837
7838 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7839 {
7840 if (!wxPyCheckForApp()) SWIG_fail;
7841 PyThreadState* __tstate = wxPyBeginAllowThreads();
7842 wxWakeUpMainThread();
7843 wxPyEndAllowThreads(__tstate);
7844 if (PyErr_Occurred()) SWIG_fail;
7845 }
7846 resultobj = SWIG_Py_Void();
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7854 PyObject *resultobj = 0;
7855
7856 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7857 {
7858 if (!wxPyCheckForApp()) SWIG_fail;
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 wxMutexGuiEnter();
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_Py_Void();
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7872 PyObject *resultobj = 0;
7873
7874 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7875 {
7876 if (!wxPyCheckForApp()) SWIG_fail;
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 wxMutexGuiLeave();
7879 wxPyEndAllowThreads(__tstate);
7880 if (PyErr_Occurred()) SWIG_fail;
7881 }
7882 resultobj = SWIG_Py_Void();
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7890 PyObject *resultobj = 0;
7891 wxMutexGuiLocker *result = 0 ;
7892
7893 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7894 {
7895 if (!wxPyCheckForApp()) SWIG_fail;
7896 PyThreadState* __tstate = wxPyBeginAllowThreads();
7897 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7902 return resultobj;
7903 fail:
7904 return NULL;
7905 }
7906
7907
7908 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7909 PyObject *resultobj = 0;
7910 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7911 void *argp1 = 0 ;
7912 int res1 = 0 ;
7913 PyObject *swig_obj[1] ;
7914
7915 if (!args) SWIG_fail;
7916 swig_obj[0] = args;
7917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7920 }
7921 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 delete arg1;
7925
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7937 PyObject *obj;
7938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7939 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7940 return SWIG_Py_Void();
7941 }
7942
7943 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 return SWIG_Python_InitShadowInstance(args);
7945 }
7946
7947 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7948 PyObject *resultobj = 0;
7949 bool result;
7950
7951 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7952 {
7953 PyThreadState* __tstate = wxPyBeginAllowThreads();
7954 result = (bool)wxThread_IsMain();
7955 wxPyEndAllowThreads(__tstate);
7956 if (PyErr_Occurred()) SWIG_fail;
7957 }
7958 {
7959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7960 }
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj = 0;
7969 wxString *arg1 = 0 ;
7970 wxToolTip *result = 0 ;
7971 bool temp1 = false ;
7972 PyObject * obj0 = 0 ;
7973 char * kwnames[] = {
7974 (char *) "tip", NULL
7975 };
7976
7977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7978 {
7979 arg1 = wxString_in_helper(obj0);
7980 if (arg1 == NULL) SWIG_fail;
7981 temp1 = true;
7982 }
7983 {
7984 if (!wxPyCheckForApp()) SWIG_fail;
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7991 {
7992 if (temp1)
7993 delete arg1;
7994 }
7995 return resultobj;
7996 fail:
7997 {
7998 if (temp1)
7999 delete arg1;
8000 }
8001 return NULL;
8002 }
8003
8004
8005 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8006 PyObject *resultobj = 0;
8007 wxToolTip *arg1 = (wxToolTip *) 0 ;
8008 void *argp1 = 0 ;
8009 int res1 = 0 ;
8010 PyObject *swig_obj[1] ;
8011
8012 if (!args) SWIG_fail;
8013 swig_obj[0] = args;
8014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8015 if (!SWIG_IsOK(res1)) {
8016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8017 }
8018 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 delete arg1;
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_Py_Void();
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxToolTip *arg1 = (wxToolTip *) 0 ;
8036 wxString *arg2 = 0 ;
8037 void *argp1 = 0 ;
8038 int res1 = 0 ;
8039 bool temp2 = false ;
8040 PyObject * obj0 = 0 ;
8041 PyObject * obj1 = 0 ;
8042 char * kwnames[] = {
8043 (char *) "self",(char *) "tip", NULL
8044 };
8045
8046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8048 if (!SWIG_IsOK(res1)) {
8049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8050 }
8051 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8052 {
8053 arg2 = wxString_in_helper(obj1);
8054 if (arg2 == NULL) SWIG_fail;
8055 temp2 = true;
8056 }
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 (arg1)->SetTip((wxString const &)*arg2);
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 resultobj = SWIG_Py_Void();
8064 {
8065 if (temp2)
8066 delete arg2;
8067 }
8068 return resultobj;
8069 fail:
8070 {
8071 if (temp2)
8072 delete arg2;
8073 }
8074 return NULL;
8075 }
8076
8077
8078 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8079 PyObject *resultobj = 0;
8080 wxToolTip *arg1 = (wxToolTip *) 0 ;
8081 wxString result;
8082 void *argp1 = 0 ;
8083 int res1 = 0 ;
8084 PyObject *swig_obj[1] ;
8085
8086 if (!args) SWIG_fail;
8087 swig_obj[0] = args;
8088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8089 if (!SWIG_IsOK(res1)) {
8090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8091 }
8092 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (arg1)->GetTip();
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 #if wxUSE_UNICODE
8101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8102 #else
8103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8104 #endif
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 PyObject *resultobj = 0;
8114 wxToolTip *arg1 = (wxToolTip *) 0 ;
8115 wxWindow *result = 0 ;
8116 void *argp1 = 0 ;
8117 int res1 = 0 ;
8118 PyObject *swig_obj[1] ;
8119
8120 if (!args) SWIG_fail;
8121 swig_obj[0] = args;
8122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8123 if (!SWIG_IsOK(res1)) {
8124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8125 }
8126 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8127 {
8128 PyThreadState* __tstate = wxPyBeginAllowThreads();
8129 result = (wxWindow *)(arg1)->GetWindow();
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 {
8134 resultobj = wxPyMake_wxObject(result, 0);
8135 }
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8143 PyObject *resultobj = 0;
8144 bool arg1 ;
8145 bool val1 ;
8146 int ecode1 = 0 ;
8147 PyObject * obj0 = 0 ;
8148 char * kwnames[] = {
8149 (char *) "flag", NULL
8150 };
8151
8152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8153 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8154 if (!SWIG_IsOK(ecode1)) {
8155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8156 }
8157 arg1 = static_cast< bool >(val1);
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 wxToolTip::Enable(arg1);
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_Py_Void();
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj = 0;
8173 long arg1 ;
8174 long val1 ;
8175 int ecode1 = 0 ;
8176 PyObject * obj0 = 0 ;
8177 char * kwnames[] = {
8178 (char *) "milliseconds", NULL
8179 };
8180
8181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8182 ecode1 = SWIG_AsVal_long(obj0, &val1);
8183 if (!SWIG_IsOK(ecode1)) {
8184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8185 }
8186 arg1 = static_cast< long >(val1);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 wxToolTip::SetDelay(arg1);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_Py_Void();
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8201 PyObject *obj;
8202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8203 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8204 return SWIG_Py_Void();
8205 }
8206
8207 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 return SWIG_Python_InitShadowInstance(args);
8209 }
8210
8211 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj = 0;
8213 wxWindow *arg1 = (wxWindow *) 0 ;
8214 wxSize *arg2 = 0 ;
8215 wxCaret *result = 0 ;
8216 void *argp1 = 0 ;
8217 int res1 = 0 ;
8218 wxSize temp2 ;
8219 PyObject * obj0 = 0 ;
8220 PyObject * obj1 = 0 ;
8221 char * kwnames[] = {
8222 (char *) "window",(char *) "size", NULL
8223 };
8224
8225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8229 }
8230 arg1 = reinterpret_cast< wxWindow * >(argp1);
8231 {
8232 arg2 = &temp2;
8233 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8234 }
8235 {
8236 if (!wxPyCheckForApp()) SWIG_fail;
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8250 PyObject *resultobj = 0;
8251 wxCaret *arg1 = (wxCaret *) 0 ;
8252 void *argp1 = 0 ;
8253 int res1 = 0 ;
8254 PyObject *swig_obj[1] ;
8255
8256 if (!args) SWIG_fail;
8257 swig_obj[0] = args;
8258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8261 }
8262 arg1 = reinterpret_cast< wxCaret * >(argp1);
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 delete arg1;
8266
8267 wxPyEndAllowThreads(__tstate);
8268 if (PyErr_Occurred()) SWIG_fail;
8269 }
8270 resultobj = SWIG_Py_Void();
8271 return resultobj;
8272 fail:
8273 return NULL;
8274 }
8275
8276
8277 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8278 PyObject *resultobj = 0;
8279 wxCaret *arg1 = (wxCaret *) 0 ;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 PyObject *swig_obj[1] ;
8283
8284 if (!args) SWIG_fail;
8285 swig_obj[0] = args;
8286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8287 if (!SWIG_IsOK(res1)) {
8288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8289 }
8290 arg1 = reinterpret_cast< wxCaret * >(argp1);
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 wxCaret_Destroy(arg1);
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 resultobj = SWIG_Py_Void();
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8305 PyObject *resultobj = 0;
8306 wxCaret *arg1 = (wxCaret *) 0 ;
8307 bool result;
8308 void *argp1 = 0 ;
8309 int res1 = 0 ;
8310 PyObject *swig_obj[1] ;
8311
8312 if (!args) SWIG_fail;
8313 swig_obj[0] = args;
8314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8315 if (!SWIG_IsOK(res1)) {
8316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8317 }
8318 arg1 = reinterpret_cast< wxCaret * >(argp1);
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 result = (bool)(arg1)->IsOk();
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 {
8326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8335 PyObject *resultobj = 0;
8336 wxCaret *arg1 = (wxCaret *) 0 ;
8337 bool result;
8338 void *argp1 = 0 ;
8339 int res1 = 0 ;
8340 PyObject *swig_obj[1] ;
8341
8342 if (!args) SWIG_fail;
8343 swig_obj[0] = args;
8344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8345 if (!SWIG_IsOK(res1)) {
8346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8347 }
8348 arg1 = reinterpret_cast< wxCaret * >(argp1);
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 result = (bool)(arg1)->IsVisible();
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 {
8356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8357 }
8358 return resultobj;
8359 fail:
8360 return NULL;
8361 }
8362
8363
8364 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8365 PyObject *resultobj = 0;
8366 wxCaret *arg1 = (wxCaret *) 0 ;
8367 wxPoint result;
8368 void *argp1 = 0 ;
8369 int res1 = 0 ;
8370 PyObject *swig_obj[1] ;
8371
8372 if (!args) SWIG_fail;
8373 swig_obj[0] = args;
8374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8377 }
8378 arg1 = reinterpret_cast< wxCaret * >(argp1);
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (arg1)->GetPosition();
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8393 PyObject *resultobj = 0;
8394 wxCaret *arg1 = (wxCaret *) 0 ;
8395 int *arg2 = (int *) 0 ;
8396 int *arg3 = (int *) 0 ;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 int temp2 ;
8400 int res2 = SWIG_TMPOBJ ;
8401 int temp3 ;
8402 int res3 = SWIG_TMPOBJ ;
8403 PyObject *swig_obj[1] ;
8404
8405 arg2 = &temp2;
8406 arg3 = &temp3;
8407 if (!args) SWIG_fail;
8408 swig_obj[0] = args;
8409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8410 if (!SWIG_IsOK(res1)) {
8411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8412 }
8413 arg1 = reinterpret_cast< wxCaret * >(argp1);
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 (arg1)->GetPosition(arg2,arg3);
8417 wxPyEndAllowThreads(__tstate);
8418 if (PyErr_Occurred()) SWIG_fail;
8419 }
8420 resultobj = SWIG_Py_Void();
8421 if (SWIG_IsTmpObj(res2)) {
8422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8423 } else {
8424 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8426 }
8427 if (SWIG_IsTmpObj(res3)) {
8428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8429 } else {
8430 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8432 }
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8440 PyObject *resultobj = 0;
8441 wxCaret *arg1 = (wxCaret *) 0 ;
8442 wxSize result;
8443 void *argp1 = 0 ;
8444 int res1 = 0 ;
8445 PyObject *swig_obj[1] ;
8446
8447 if (!args) SWIG_fail;
8448 swig_obj[0] = args;
8449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8452 }
8453 arg1 = reinterpret_cast< wxCaret * >(argp1);
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->GetSize();
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8468 PyObject *resultobj = 0;
8469 wxCaret *arg1 = (wxCaret *) 0 ;
8470 int *arg2 = (int *) 0 ;
8471 int *arg3 = (int *) 0 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 int temp2 ;
8475 int res2 = SWIG_TMPOBJ ;
8476 int temp3 ;
8477 int res3 = SWIG_TMPOBJ ;
8478 PyObject *swig_obj[1] ;
8479
8480 arg2 = &temp2;
8481 arg3 = &temp3;
8482 if (!args) SWIG_fail;
8483 swig_obj[0] = args;
8484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8487 }
8488 arg1 = reinterpret_cast< wxCaret * >(argp1);
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 (arg1)->GetSize(arg2,arg3);
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_Py_Void();
8496 if (SWIG_IsTmpObj(res2)) {
8497 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8498 } else {
8499 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8501 }
8502 if (SWIG_IsTmpObj(res3)) {
8503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8504 } else {
8505 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8507 }
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 wxWindow *result = 0 ;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 PyObject *swig_obj[1] ;
8521
8522 if (!args) SWIG_fail;
8523 swig_obj[0] = args;
8524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8527 }
8528 arg1 = reinterpret_cast< wxCaret * >(argp1);
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (wxWindow *)(arg1)->GetWindow();
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = wxPyMake_wxObject(result, 0);
8537 }
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8545 PyObject *resultobj = 0;
8546 wxCaret *arg1 = (wxCaret *) 0 ;
8547 int arg2 ;
8548 int arg3 ;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 int val2 ;
8552 int ecode2 = 0 ;
8553 int val3 ;
8554 int ecode3 = 0 ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 PyObject * obj2 = 0 ;
8558 char * kwnames[] = {
8559 (char *) "self",(char *) "x",(char *) "y", NULL
8560 };
8561
8562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8564 if (!SWIG_IsOK(res1)) {
8565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8566 }
8567 arg1 = reinterpret_cast< wxCaret * >(argp1);
8568 ecode2 = SWIG_AsVal_int(obj1, &val2);
8569 if (!SWIG_IsOK(ecode2)) {
8570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8571 }
8572 arg2 = static_cast< int >(val2);
8573 ecode3 = SWIG_AsVal_int(obj2, &val3);
8574 if (!SWIG_IsOK(ecode3)) {
8575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8576 }
8577 arg3 = static_cast< int >(val3);
8578 {
8579 PyThreadState* __tstate = wxPyBeginAllowThreads();
8580 (arg1)->Move(arg2,arg3);
8581 wxPyEndAllowThreads(__tstate);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_Py_Void();
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxCaret *arg1 = (wxCaret *) 0 ;
8594 wxPoint *arg2 = 0 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 wxPoint temp2 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "pt", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8608 }
8609 arg1 = reinterpret_cast< wxCaret * >(argp1);
8610 {
8611 arg2 = &temp2;
8612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8613 }
8614 {
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 (arg1)->Move((wxPoint const &)*arg2);
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 resultobj = SWIG_Py_Void();
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj = 0;
8629 wxCaret *arg1 = (wxCaret *) 0 ;
8630 int arg2 ;
8631 int arg3 ;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 int val2 ;
8635 int ecode2 = 0 ;
8636 int val3 ;
8637 int ecode3 = 0 ;
8638 PyObject * obj0 = 0 ;
8639 PyObject * obj1 = 0 ;
8640 PyObject * obj2 = 0 ;
8641 char * kwnames[] = {
8642 (char *) "self",(char *) "width",(char *) "height", NULL
8643 };
8644
8645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8649 }
8650 arg1 = reinterpret_cast< wxCaret * >(argp1);
8651 ecode2 = SWIG_AsVal_int(obj1, &val2);
8652 if (!SWIG_IsOK(ecode2)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8654 }
8655 arg2 = static_cast< int >(val2);
8656 ecode3 = SWIG_AsVal_int(obj2, &val3);
8657 if (!SWIG_IsOK(ecode3)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8659 }
8660 arg3 = static_cast< int >(val3);
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 (arg1)->SetSize(arg2,arg3);
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 resultobj = SWIG_Py_Void();
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj = 0;
8676 wxCaret *arg1 = (wxCaret *) 0 ;
8677 wxSize *arg2 = 0 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 wxSize temp2 ;
8681 PyObject * obj0 = 0 ;
8682 PyObject * obj1 = 0 ;
8683 char * kwnames[] = {
8684 (char *) "self",(char *) "size", NULL
8685 };
8686
8687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8689 if (!SWIG_IsOK(res1)) {
8690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8691 }
8692 arg1 = reinterpret_cast< wxCaret * >(argp1);
8693 {
8694 arg2 = &temp2;
8695 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8696 }
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 (arg1)->SetSize((wxSize const &)*arg2);
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_Py_Void();
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj = 0;
8712 wxCaret *arg1 = (wxCaret *) 0 ;
8713 int arg2 = (int) true ;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 int val2 ;
8717 int ecode2 = 0 ;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 char * kwnames[] = {
8721 (char *) "self",(char *) "show", NULL
8722 };
8723
8724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8726 if (!SWIG_IsOK(res1)) {
8727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8728 }
8729 arg1 = reinterpret_cast< wxCaret * >(argp1);
8730 if (obj1) {
8731 ecode2 = SWIG_AsVal_int(obj1, &val2);
8732 if (!SWIG_IsOK(ecode2)) {
8733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8734 }
8735 arg2 = static_cast< int >(val2);
8736 }
8737 {
8738 PyThreadState* __tstate = wxPyBeginAllowThreads();
8739 (arg1)->Show(arg2);
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 resultobj = SWIG_Py_Void();
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8751 PyObject *resultobj = 0;
8752 wxCaret *arg1 = (wxCaret *) 0 ;
8753 void *argp1 = 0 ;
8754 int res1 = 0 ;
8755 PyObject *swig_obj[1] ;
8756
8757 if (!args) SWIG_fail;
8758 swig_obj[0] = args;
8759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8760 if (!SWIG_IsOK(res1)) {
8761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8762 }
8763 arg1 = reinterpret_cast< wxCaret * >(argp1);
8764 {
8765 PyThreadState* __tstate = wxPyBeginAllowThreads();
8766 (arg1)->Hide();
8767 wxPyEndAllowThreads(__tstate);
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 resultobj = SWIG_Py_Void();
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8778 PyObject *resultobj = 0;
8779 int result;
8780
8781 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 result = (int)wxCaret::GetBlinkTime();
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 resultobj = SWIG_From_int(static_cast< int >(result));
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 int arg1 ;
8798 int val1 ;
8799 int ecode1 = 0 ;
8800 PyObject * obj0 = 0 ;
8801 char * kwnames[] = {
8802 (char *) "milliseconds", NULL
8803 };
8804
8805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8806 ecode1 = SWIG_AsVal_int(obj0, &val1);
8807 if (!SWIG_IsOK(ecode1)) {
8808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8809 }
8810 arg1 = static_cast< int >(val1);
8811 {
8812 PyThreadState* __tstate = wxPyBeginAllowThreads();
8813 wxCaret::SetBlinkTime(arg1);
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8825 PyObject *obj;
8826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8827 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8828 return SWIG_Py_Void();
8829 }
8830
8831 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8832 return SWIG_Python_InitShadowInstance(args);
8833 }
8834
8835 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8838 wxBusyCursor *result = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 PyObject * obj0 = 0 ;
8842 char * kwnames[] = {
8843 (char *) "cursor", NULL
8844 };
8845
8846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8847 if (obj0) {
8848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8851 }
8852 arg1 = reinterpret_cast< wxCursor * >(argp1);
8853 }
8854 {
8855 if (!wxPyCheckForApp()) SWIG_fail;
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *resultobj = 0;
8870 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 PyObject *swig_obj[1] ;
8874
8875 if (!args) SWIG_fail;
8876 swig_obj[0] = args;
8877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8878 if (!SWIG_IsOK(res1)) {
8879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8880 }
8881 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8882 {
8883 PyThreadState* __tstate = wxPyBeginAllowThreads();
8884 delete arg1;
8885
8886 wxPyEndAllowThreads(__tstate);
8887 if (PyErr_Occurred()) SWIG_fail;
8888 }
8889 resultobj = SWIG_Py_Void();
8890 return resultobj;
8891 fail:
8892 return NULL;
8893 }
8894
8895
8896 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8897 PyObject *obj;
8898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8899 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8900 return SWIG_Py_Void();
8901 }
8902
8903 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8904 return SWIG_Python_InitShadowInstance(args);
8905 }
8906
8907 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxWindow *arg1 = (wxWindow *) NULL ;
8910 wxWindowDisabler *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 PyObject * obj0 = 0 ;
8914 char * kwnames[] = {
8915 (char *) "winToSkip", NULL
8916 };
8917
8918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8919 if (obj0) {
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8923 }
8924 arg1 = reinterpret_cast< wxWindow * >(argp1);
8925 }
8926 {
8927 if (!wxPyCheckForApp()) SWIG_fail;
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 PyObject *resultobj = 0;
8942 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 PyObject *swig_obj[1] ;
8946
8947 if (!args) SWIG_fail;
8948 swig_obj[0] = args;
8949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8950 if (!SWIG_IsOK(res1)) {
8951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8952 }
8953 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 delete arg1;
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *obj;
8970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8971 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8972 return SWIG_Py_Void();
8973 }
8974
8975 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 return SWIG_Python_InitShadowInstance(args);
8977 }
8978
8979 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8980 PyObject *resultobj = 0;
8981 wxString *arg1 = 0 ;
8982 wxBusyInfo *result = 0 ;
8983 bool temp1 = false ;
8984 PyObject * obj0 = 0 ;
8985 char * kwnames[] = {
8986 (char *) "message", NULL
8987 };
8988
8989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8990 {
8991 arg1 = wxString_in_helper(obj0);
8992 if (arg1 == NULL) SWIG_fail;
8993 temp1 = true;
8994 }
8995 {
8996 if (!wxPyCheckForApp()) SWIG_fail;
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8999 wxPyEndAllowThreads(__tstate);
9000 if (PyErr_Occurred()) SWIG_fail;
9001 }
9002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9003 {
9004 if (temp1)
9005 delete arg1;
9006 }
9007 return resultobj;
9008 fail:
9009 {
9010 if (temp1)
9011 delete arg1;
9012 }
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9018 PyObject *resultobj = 0;
9019 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 PyObject *swig_obj[1] ;
9023
9024 if (!args) SWIG_fail;
9025 swig_obj[0] = args;
9026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9027 if (!SWIG_IsOK(res1)) {
9028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9029 }
9030 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 delete arg1;
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 resultobj = SWIG_Py_Void();
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9046 PyObject *obj;
9047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9048 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9049 return SWIG_Py_Void();
9050 }
9051
9052 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 return SWIG_Python_InitShadowInstance(args);
9054 }
9055
9056 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9057 PyObject *resultobj = 0;
9058 wxStopWatch *result = 0 ;
9059
9060 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (wxStopWatch *)new wxStopWatch();
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9075 PyObject *resultobj = 0;
9076 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9077 long arg2 = (long) 0 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 long val2 ;
9081 int ecode2 = 0 ;
9082 PyObject * obj0 = 0 ;
9083 PyObject * obj1 = 0 ;
9084 char * kwnames[] = {
9085 (char *) "self",(char *) "t0", NULL
9086 };
9087
9088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9092 }
9093 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9094 if (obj1) {
9095 ecode2 = SWIG_AsVal_long(obj1, &val2);
9096 if (!SWIG_IsOK(ecode2)) {
9097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9098 }
9099 arg2 = static_cast< long >(val2);
9100 }
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->Start(arg2);
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *resultobj = 0;
9116 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9117 void *argp1 = 0 ;
9118 int res1 = 0 ;
9119 PyObject *swig_obj[1] ;
9120
9121 if (!args) SWIG_fail;
9122 swig_obj[0] = args;
9123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9124 if (!SWIG_IsOK(res1)) {
9125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9126 }
9127 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9128 {
9129 PyThreadState* __tstate = wxPyBeginAllowThreads();
9130 (arg1)->Pause();
9131 wxPyEndAllowThreads(__tstate);
9132 if (PyErr_Occurred()) SWIG_fail;
9133 }
9134 resultobj = SWIG_Py_Void();
9135 return resultobj;
9136 fail:
9137 return NULL;
9138 }
9139
9140
9141 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9142 PyObject *resultobj = 0;
9143 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9144 void *argp1 = 0 ;
9145 int res1 = 0 ;
9146 PyObject *swig_obj[1] ;
9147
9148 if (!args) SWIG_fail;
9149 swig_obj[0] = args;
9150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9151 if (!SWIG_IsOK(res1)) {
9152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9153 }
9154 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 (arg1)->Resume();
9158 wxPyEndAllowThreads(__tstate);
9159 if (PyErr_Occurred()) SWIG_fail;
9160 }
9161 resultobj = SWIG_Py_Void();
9162 return resultobj;
9163 fail:
9164 return NULL;
9165 }
9166
9167
9168 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9169 PyObject *resultobj = 0;
9170 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9171 long result;
9172 void *argp1 = 0 ;
9173 int res1 = 0 ;
9174 PyObject *swig_obj[1] ;
9175
9176 if (!args) SWIG_fail;
9177 swig_obj[0] = args;
9178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9179 if (!SWIG_IsOK(res1)) {
9180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9181 }
9182 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 result = (long)((wxStopWatch const *)arg1)->Time();
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 resultobj = SWIG_From_long(static_cast< long >(result));
9190 return resultobj;
9191 fail:
9192 return NULL;
9193 }
9194
9195
9196 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9197 PyObject *obj;
9198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9199 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9200 return SWIG_Py_Void();
9201 }
9202
9203 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9204 return SWIG_Python_InitShadowInstance(args);
9205 }
9206
9207 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9208 PyObject *resultobj = 0;
9209 int arg1 = (int) 9 ;
9210 int arg2 = (int) wxID_FILE1 ;
9211 wxFileHistory *result = 0 ;
9212 int val1 ;
9213 int ecode1 = 0 ;
9214 int val2 ;
9215 int ecode2 = 0 ;
9216 PyObject * obj0 = 0 ;
9217 PyObject * obj1 = 0 ;
9218 char * kwnames[] = {
9219 (char *) "maxFiles",(char *) "idBase", NULL
9220 };
9221
9222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9223 if (obj0) {
9224 ecode1 = SWIG_AsVal_int(obj0, &val1);
9225 if (!SWIG_IsOK(ecode1)) {
9226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9227 }
9228 arg1 = static_cast< int >(val1);
9229 }
9230 if (obj1) {
9231 ecode2 = SWIG_AsVal_int(obj1, &val2);
9232 if (!SWIG_IsOK(ecode2)) {
9233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9234 }
9235 arg2 = static_cast< int >(val2);
9236 }
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 PyObject *resultobj = 0;
9252 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9253 void *argp1 = 0 ;
9254 int res1 = 0 ;
9255 PyObject *swig_obj[1] ;
9256
9257 if (!args) SWIG_fail;
9258 swig_obj[0] = args;
9259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9260 if (!SWIG_IsOK(res1)) {
9261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9262 }
9263 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 delete arg1;
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_Py_Void();
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9279 PyObject *resultobj = 0;
9280 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9281 wxString *arg2 = 0 ;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 bool temp2 = false ;
9285 PyObject * obj0 = 0 ;
9286 PyObject * obj1 = 0 ;
9287 char * kwnames[] = {
9288 (char *) "self",(char *) "file", NULL
9289 };
9290
9291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9295 }
9296 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9297 {
9298 arg2 = wxString_in_helper(obj1);
9299 if (arg2 == NULL) SWIG_fail;
9300 temp2 = true;
9301 }
9302 {
9303 PyThreadState* __tstate = wxPyBeginAllowThreads();
9304 (arg1)->AddFileToHistory((wxString const &)*arg2);
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_Py_Void();
9309 {
9310 if (temp2)
9311 delete arg2;
9312 }
9313 return resultobj;
9314 fail:
9315 {
9316 if (temp2)
9317 delete arg2;
9318 }
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj = 0;
9325 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9326 int arg2 ;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 int val2 ;
9330 int ecode2 = 0 ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 char * kwnames[] = {
9334 (char *) "self",(char *) "i", NULL
9335 };
9336
9337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9341 }
9342 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9343 ecode2 = SWIG_AsVal_int(obj1, &val2);
9344 if (!SWIG_IsOK(ecode2)) {
9345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9346 }
9347 arg2 = static_cast< int >(val2);
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 (arg1)->RemoveFileFromHistory(arg2);
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 resultobj = SWIG_Py_Void();
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9362 PyObject *resultobj = 0;
9363 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9364 int result;
9365 void *argp1 = 0 ;
9366 int res1 = 0 ;
9367 PyObject *swig_obj[1] ;
9368
9369 if (!args) SWIG_fail;
9370 swig_obj[0] = args;
9371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9372 if (!SWIG_IsOK(res1)) {
9373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9374 }
9375 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9376 {
9377 PyThreadState* __tstate = wxPyBeginAllowThreads();
9378 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 resultobj = SWIG_From_int(static_cast< int >(result));
9383 return resultobj;
9384 fail:
9385 return NULL;
9386 }
9387
9388
9389 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj = 0;
9391 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9392 wxMenu *arg2 = (wxMenu *) 0 ;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 void *argp2 = 0 ;
9396 int res2 = 0 ;
9397 PyObject * obj0 = 0 ;
9398 PyObject * obj1 = 0 ;
9399 char * kwnames[] = {
9400 (char *) "self",(char *) "menu", NULL
9401 };
9402
9403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9405 if (!SWIG_IsOK(res1)) {
9406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9407 }
9408 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9410 if (!SWIG_IsOK(res2)) {
9411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9412 }
9413 arg2 = reinterpret_cast< wxMenu * >(argp2);
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 (arg1)->UseMenu(arg2);
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 resultobj = SWIG_Py_Void();
9421 return resultobj;
9422 fail:
9423 return NULL;
9424 }
9425
9426
9427 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9428 PyObject *resultobj = 0;
9429 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9430 wxMenu *arg2 = (wxMenu *) 0 ;
9431 void *argp1 = 0 ;
9432 int res1 = 0 ;
9433 void *argp2 = 0 ;
9434 int res2 = 0 ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 char * kwnames[] = {
9438 (char *) "self",(char *) "menu", NULL
9439 };
9440
9441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9443 if (!SWIG_IsOK(res1)) {
9444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9445 }
9446 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9447 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9448 if (!SWIG_IsOK(res2)) {
9449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9450 }
9451 arg2 = reinterpret_cast< wxMenu * >(argp2);
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 (arg1)->RemoveMenu(arg2);
9455 wxPyEndAllowThreads(__tstate);
9456 if (PyErr_Occurred()) SWIG_fail;
9457 }
9458 resultobj = SWIG_Py_Void();
9459 return resultobj;
9460 fail:
9461 return NULL;
9462 }
9463
9464
9465 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9466 PyObject *resultobj = 0;
9467 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9468 wxConfigBase *arg2 = 0 ;
9469 void *argp1 = 0 ;
9470 int res1 = 0 ;
9471 void *argp2 = 0 ;
9472 int res2 = 0 ;
9473 PyObject * obj0 = 0 ;
9474 PyObject * obj1 = 0 ;
9475 char * kwnames[] = {
9476 (char *) "self",(char *) "config", NULL
9477 };
9478
9479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9481 if (!SWIG_IsOK(res1)) {
9482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9483 }
9484 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9486 if (!SWIG_IsOK(res2)) {
9487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9488 }
9489 if (!argp2) {
9490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9491 }
9492 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 (arg1)->Load(*arg2);
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 resultobj = SWIG_Py_Void();
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj = 0;
9508 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9509 wxConfigBase *arg2 = 0 ;
9510 void *argp1 = 0 ;
9511 int res1 = 0 ;
9512 void *argp2 = 0 ;
9513 int res2 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 char * kwnames[] = {
9517 (char *) "self",(char *) "config", NULL
9518 };
9519
9520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9524 }
9525 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9526 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9527 if (!SWIG_IsOK(res2)) {
9528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9529 }
9530 if (!argp2) {
9531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9532 }
9533 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9534 {
9535 PyThreadState* __tstate = wxPyBeginAllowThreads();
9536 (arg1)->Save(*arg2);
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 resultobj = SWIG_Py_Void();
9541 return resultobj;
9542 fail:
9543 return NULL;
9544 }
9545
9546
9547 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9548 PyObject *resultobj = 0;
9549 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 PyObject *swig_obj[1] ;
9553
9554 if (!args) SWIG_fail;
9555 swig_obj[0] = args;
9556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9557 if (!SWIG_IsOK(res1)) {
9558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9559 }
9560 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 (arg1)->AddFilesToMenu();
9564 wxPyEndAllowThreads(__tstate);
9565 if (PyErr_Occurred()) SWIG_fail;
9566 }
9567 resultobj = SWIG_Py_Void();
9568 return resultobj;
9569 fail:
9570 return NULL;
9571 }
9572
9573
9574 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj = 0;
9576 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9577 wxMenu *arg2 = (wxMenu *) 0 ;
9578 void *argp1 = 0 ;
9579 int res1 = 0 ;
9580 void *argp2 = 0 ;
9581 int res2 = 0 ;
9582 PyObject * obj0 = 0 ;
9583 PyObject * obj1 = 0 ;
9584 char * kwnames[] = {
9585 (char *) "self",(char *) "menu", NULL
9586 };
9587
9588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9592 }
9593 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9595 if (!SWIG_IsOK(res2)) {
9596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9597 }
9598 arg2 = reinterpret_cast< wxMenu * >(argp2);
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 (arg1)->AddFilesToMenu(arg2);
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 resultobj = SWIG_Py_Void();
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9613 PyObject *resultobj = 0;
9614 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9615 int arg2 ;
9616 wxString result;
9617 void *argp1 = 0 ;
9618 int res1 = 0 ;
9619 int val2 ;
9620 int ecode2 = 0 ;
9621 PyObject * obj0 = 0 ;
9622 PyObject * obj1 = 0 ;
9623 char * kwnames[] = {
9624 (char *) "self",(char *) "i", NULL
9625 };
9626
9627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9629 if (!SWIG_IsOK(res1)) {
9630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9631 }
9632 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9633 ecode2 = SWIG_AsVal_int(obj1, &val2);
9634 if (!SWIG_IsOK(ecode2)) {
9635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9636 }
9637 arg2 = static_cast< int >(val2);
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 {
9645 #if wxUSE_UNICODE
9646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9647 #else
9648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9649 #endif
9650 }
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9658 PyObject *resultobj = 0;
9659 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9660 int result;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 PyObject *swig_obj[1] ;
9664
9665 if (!args) SWIG_fail;
9666 swig_obj[0] = args;
9667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9668 if (!SWIG_IsOK(res1)) {
9669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9670 }
9671 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 result = (int)((wxFileHistory const *)arg1)->GetCount();
9675 wxPyEndAllowThreads(__tstate);
9676 if (PyErr_Occurred()) SWIG_fail;
9677 }
9678 resultobj = SWIG_From_int(static_cast< int >(result));
9679 return resultobj;
9680 fail:
9681 return NULL;
9682 }
9683
9684
9685 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9686 PyObject *obj;
9687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9688 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9689 return SWIG_Py_Void();
9690 }
9691
9692 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693 return SWIG_Python_InitShadowInstance(args);
9694 }
9695
9696 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj = 0;
9698 wxString *arg1 = 0 ;
9699 wxString const &arg2_defvalue = wxPyEmptyString ;
9700 wxString *arg2 = (wxString *) &arg2_defvalue ;
9701 wxSingleInstanceChecker *result = 0 ;
9702 bool temp1 = false ;
9703 bool temp2 = false ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 char * kwnames[] = {
9707 (char *) "name",(char *) "path", NULL
9708 };
9709
9710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9711 {
9712 arg1 = wxString_in_helper(obj0);
9713 if (arg1 == NULL) SWIG_fail;
9714 temp1 = true;
9715 }
9716 if (obj1) {
9717 {
9718 arg2 = wxString_in_helper(obj1);
9719 if (arg2 == NULL) SWIG_fail;
9720 temp2 = true;
9721 }
9722 }
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9730 {
9731 if (temp1)
9732 delete arg1;
9733 }
9734 {
9735 if (temp2)
9736 delete arg2;
9737 }
9738 return resultobj;
9739 fail:
9740 {
9741 if (temp1)
9742 delete arg1;
9743 }
9744 {
9745 if (temp2)
9746 delete arg2;
9747 }
9748 return NULL;
9749 }
9750
9751
9752 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9753 PyObject *resultobj = 0;
9754 wxSingleInstanceChecker *result = 0 ;
9755
9756 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9771 PyObject *resultobj = 0;
9772 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 PyObject *swig_obj[1] ;
9776
9777 if (!args) SWIG_fail;
9778 swig_obj[0] = args;
9779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9780 if (!SWIG_IsOK(res1)) {
9781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9782 }
9783 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 delete arg1;
9787
9788 wxPyEndAllowThreads(__tstate);
9789 if (PyErr_Occurred()) SWIG_fail;
9790 }
9791 resultobj = SWIG_Py_Void();
9792 return resultobj;
9793 fail:
9794 return NULL;
9795 }
9796
9797
9798 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj = 0;
9800 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9801 wxString *arg2 = 0 ;
9802 wxString const &arg3_defvalue = wxPyEmptyString ;
9803 wxString *arg3 = (wxString *) &arg3_defvalue ;
9804 bool result;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 bool temp2 = false ;
9808 bool temp3 = false ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char * kwnames[] = {
9813 (char *) "self",(char *) "name",(char *) "path", NULL
9814 };
9815
9816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9820 }
9821 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9822 {
9823 arg2 = wxString_in_helper(obj1);
9824 if (arg2 == NULL) SWIG_fail;
9825 temp2 = true;
9826 }
9827 if (obj2) {
9828 {
9829 arg3 = wxString_in_helper(obj2);
9830 if (arg3 == NULL) SWIG_fail;
9831 temp3 = true;
9832 }
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9837 wxPyEndAllowThreads(__tstate);
9838 if (PyErr_Occurred()) SWIG_fail;
9839 }
9840 {
9841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9842 }
9843 {
9844 if (temp2)
9845 delete arg2;
9846 }
9847 {
9848 if (temp3)
9849 delete arg3;
9850 }
9851 return resultobj;
9852 fail:
9853 {
9854 if (temp2)
9855 delete arg2;
9856 }
9857 {
9858 if (temp3)
9859 delete arg3;
9860 }
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9868 bool result;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9878 }
9879 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 {
9887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9888 }
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 PyObject *obj;
9897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9898 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9899 return SWIG_Py_Void();
9900 }
9901
9902 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 return SWIG_Python_InitShadowInstance(args);
9904 }
9905
9906 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9907 PyObject *resultobj = 0;
9908 wxWindow *arg1 = (wxWindow *) 0 ;
9909 wxDC *arg2 = 0 ;
9910 bool result;
9911 void *argp1 = 0 ;
9912 int res1 = 0 ;
9913 void *argp2 = 0 ;
9914 int res2 = 0 ;
9915 PyObject * obj0 = 0 ;
9916 PyObject * obj1 = 0 ;
9917 char * kwnames[] = {
9918 (char *) "window",(char *) "dc", NULL
9919 };
9920
9921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9923 if (!SWIG_IsOK(res1)) {
9924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9925 }
9926 arg1 = reinterpret_cast< wxWindow * >(argp1);
9927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9928 if (!SWIG_IsOK(res2)) {
9929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9930 }
9931 if (!argp2) {
9932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9933 }
9934 arg2 = reinterpret_cast< wxDC * >(argp2);
9935 {
9936 PyThreadState* __tstate = wxPyBeginAllowThreads();
9937 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9938 wxPyEndAllowThreads(__tstate);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 {
9942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9943 }
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 PyObject *resultobj = 0;
9952 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9962 }
9963 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 delete arg1;
9967
9968 wxPyEndAllowThreads(__tstate);
9969 if (PyErr_Occurred()) SWIG_fail;
9970 }
9971 resultobj = SWIG_Py_Void();
9972 return resultobj;
9973 fail:
9974 return NULL;
9975 }
9976
9977
9978 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9979 PyObject *resultobj = 0;
9980 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9981 wxString result;
9982 void *argp1 = 0 ;
9983 int res1 = 0 ;
9984 PyObject *swig_obj[1] ;
9985
9986 if (!args) SWIG_fail;
9987 swig_obj[0] = args;
9988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9991 }
9992 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 result = (arg1)->GetTip();
9996 wxPyEndAllowThreads(__tstate);
9997 if (PyErr_Occurred()) SWIG_fail;
9998 }
9999 {
10000 #if wxUSE_UNICODE
10001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10002 #else
10003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10004 #endif
10005 }
10006 return resultobj;
10007 fail:
10008 return NULL;
10009 }
10010
10011
10012 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10013 PyObject *resultobj = 0;
10014 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10015 size_t result;
10016 void *argp1 = 0 ;
10017 int res1 = 0 ;
10018 PyObject *swig_obj[1] ;
10019
10020 if (!args) SWIG_fail;
10021 swig_obj[0] = args;
10022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10025 }
10026 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 result = (size_t)(arg1)->GetCurrentTip();
10030 wxPyEndAllowThreads(__tstate);
10031 if (PyErr_Occurred()) SWIG_fail;
10032 }
10033 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10034 return resultobj;
10035 fail:
10036 return NULL;
10037 }
10038
10039
10040 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10041 PyObject *resultobj = 0;
10042 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10043 wxString *arg2 = 0 ;
10044 wxString result;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 bool temp2 = false ;
10048 PyObject * obj0 = 0 ;
10049 PyObject * obj1 = 0 ;
10050 char * kwnames[] = {
10051 (char *) "self",(char *) "tip", NULL
10052 };
10053
10054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10058 }
10059 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10060 {
10061 arg2 = wxString_in_helper(obj1);
10062 if (arg2 == NULL) SWIG_fail;
10063 temp2 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 {
10072 #if wxUSE_UNICODE
10073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10074 #else
10075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10076 #endif
10077 }
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10093 PyObject *obj;
10094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10095 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10096 return SWIG_Py_Void();
10097 }
10098
10099 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj = 0;
10101 size_t arg1 ;
10102 wxPyTipProvider *result = 0 ;
10103 size_t val1 ;
10104 int ecode1 = 0 ;
10105 PyObject * obj0 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "currentTip", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10111 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10112 if (!SWIG_IsOK(ecode1)) {
10113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10114 }
10115 arg1 = static_cast< size_t >(val1);
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10123 return resultobj;
10124 fail:
10125 return NULL;
10126 }
10127
10128
10129 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10130 PyObject *resultobj = 0;
10131 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10132 PyObject *arg2 = (PyObject *) 0 ;
10133 PyObject *arg3 = (PyObject *) 0 ;
10134 void *argp1 = 0 ;
10135 int res1 = 0 ;
10136 PyObject * obj0 = 0 ;
10137 PyObject * obj1 = 0 ;
10138 PyObject * obj2 = 0 ;
10139 char * kwnames[] = {
10140 (char *) "self",(char *) "self",(char *) "_class", NULL
10141 };
10142
10143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10145 if (!SWIG_IsOK(res1)) {
10146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10147 }
10148 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10149 arg2 = obj1;
10150 arg3 = obj2;
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 (arg1)->_setCallbackInfo(arg2,arg3);
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 resultobj = SWIG_Py_Void();
10158 return resultobj;
10159 fail:
10160 return NULL;
10161 }
10162
10163
10164 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10165 PyObject *obj;
10166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10167 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10168 return SWIG_Py_Void();
10169 }
10170
10171 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10172 return SWIG_Python_InitShadowInstance(args);
10173 }
10174
10175 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj = 0;
10177 wxWindow *arg1 = (wxWindow *) 0 ;
10178 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10179 bool arg3 = (bool) true ;
10180 bool result;
10181 void *argp1 = 0 ;
10182 int res1 = 0 ;
10183 void *argp2 = 0 ;
10184 int res2 = 0 ;
10185 bool val3 ;
10186 int ecode3 = 0 ;
10187 PyObject * obj0 = 0 ;
10188 PyObject * obj1 = 0 ;
10189 PyObject * obj2 = 0 ;
10190 char * kwnames[] = {
10191 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10192 };
10193
10194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10196 if (!SWIG_IsOK(res1)) {
10197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10198 }
10199 arg1 = reinterpret_cast< wxWindow * >(argp1);
10200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10201 if (!SWIG_IsOK(res2)) {
10202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10203 }
10204 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10205 if (obj2) {
10206 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10207 if (!SWIG_IsOK(ecode3)) {
10208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10209 }
10210 arg3 = static_cast< bool >(val3);
10211 }
10212 {
10213 if (!wxPyCheckForApp()) SWIG_fail;
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 result = (bool)wxShowTip(arg1,arg2,arg3);
10216 wxPyEndAllowThreads(__tstate);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 {
10220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10221 }
10222 return resultobj;
10223 fail:
10224 return NULL;
10225 }
10226
10227
10228 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj = 0;
10230 wxString *arg1 = 0 ;
10231 size_t arg2 ;
10232 wxTipProvider *result = 0 ;
10233 bool temp1 = false ;
10234 size_t val2 ;
10235 int ecode2 = 0 ;
10236 PyObject * obj0 = 0 ;
10237 PyObject * obj1 = 0 ;
10238 char * kwnames[] = {
10239 (char *) "filename",(char *) "currentTip", NULL
10240 };
10241
10242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10243 {
10244 arg1 = wxString_in_helper(obj0);
10245 if (arg1 == NULL) SWIG_fail;
10246 temp1 = true;
10247 }
10248 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10249 if (!SWIG_IsOK(ecode2)) {
10250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10251 }
10252 arg2 = static_cast< size_t >(val2);
10253 {
10254 if (!wxPyCheckForApp()) SWIG_fail;
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10261 {
10262 if (temp1)
10263 delete arg1;
10264 }
10265 return resultobj;
10266 fail:
10267 {
10268 if (temp1)
10269 delete arg1;
10270 }
10271 return NULL;
10272 }
10273
10274
10275 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10276 PyObject *resultobj = 0;
10277 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10278 int arg2 = (int) wxID_ANY ;
10279 wxPyTimer *result = 0 ;
10280 void *argp1 = 0 ;
10281 int res1 = 0 ;
10282 int val2 ;
10283 int ecode2 = 0 ;
10284 PyObject * obj0 = 0 ;
10285 PyObject * obj1 = 0 ;
10286 char * kwnames[] = {
10287 (char *) "owner",(char *) "id", NULL
10288 };
10289
10290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10291 if (obj0) {
10292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10293 if (!SWIG_IsOK(res1)) {
10294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10295 }
10296 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10297 }
10298 if (obj1) {
10299 ecode2 = SWIG_AsVal_int(obj1, &val2);
10300 if (!SWIG_IsOK(ecode2)) {
10301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10302 }
10303 arg2 = static_cast< int >(val2);
10304 }
10305 {
10306 if (!wxPyCheckForApp()) SWIG_fail;
10307 PyThreadState* __tstate = wxPyBeginAllowThreads();
10308 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10313 return resultobj;
10314 fail:
10315 return NULL;
10316 }
10317
10318
10319 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10320 PyObject *resultobj = 0;
10321 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10322 void *argp1 = 0 ;
10323 int res1 = 0 ;
10324 PyObject *swig_obj[1] ;
10325
10326 if (!args) SWIG_fail;
10327 swig_obj[0] = args;
10328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10329 if (!SWIG_IsOK(res1)) {
10330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10331 }
10332 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 delete arg1;
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_Py_Void();
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10350 PyObject *arg2 = (PyObject *) 0 ;
10351 PyObject *arg3 = (PyObject *) 0 ;
10352 int arg4 = (int) 1 ;
10353 void *argp1 = 0 ;
10354 int res1 = 0 ;
10355 int val4 ;
10356 int ecode4 = 0 ;
10357 PyObject * obj0 = 0 ;
10358 PyObject * obj1 = 0 ;
10359 PyObject * obj2 = 0 ;
10360 PyObject * obj3 = 0 ;
10361 char * kwnames[] = {
10362 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10363 };
10364
10365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10367 if (!SWIG_IsOK(res1)) {
10368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10369 }
10370 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10371 arg2 = obj1;
10372 arg3 = obj2;
10373 if (obj3) {
10374 ecode4 = SWIG_AsVal_int(obj3, &val4);
10375 if (!SWIG_IsOK(ecode4)) {
10376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10377 }
10378 arg4 = static_cast< int >(val4);
10379 }
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10383 wxPyEndAllowThreads(__tstate);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 resultobj = SWIG_Py_Void();
10387 return resultobj;
10388 fail:
10389 return NULL;
10390 }
10391
10392
10393 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10394 PyObject *resultobj = 0;
10395 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10396 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10397 int arg3 = (int) wxID_ANY ;
10398 void *argp1 = 0 ;
10399 int res1 = 0 ;
10400 void *argp2 = 0 ;
10401 int res2 = 0 ;
10402 int val3 ;
10403 int ecode3 = 0 ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 PyObject * obj2 = 0 ;
10407 char * kwnames[] = {
10408 (char *) "self",(char *) "owner",(char *) "id", NULL
10409 };
10410
10411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10413 if (!SWIG_IsOK(res1)) {
10414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10415 }
10416 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10418 if (!SWIG_IsOK(res2)) {
10419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10420 }
10421 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10422 if (obj2) {
10423 ecode3 = SWIG_AsVal_int(obj2, &val3);
10424 if (!SWIG_IsOK(ecode3)) {
10425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10426 }
10427 arg3 = static_cast< int >(val3);
10428 }
10429 {
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 (arg1)->SetOwner(arg2,arg3);
10432 wxPyEndAllowThreads(__tstate);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 resultobj = SWIG_Py_Void();
10436 return resultobj;
10437 fail:
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10443 PyObject *resultobj = 0;
10444 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10445 wxEvtHandler *result = 0 ;
10446 void *argp1 = 0 ;
10447 int res1 = 0 ;
10448 PyObject *swig_obj[1] ;
10449
10450 if (!args) SWIG_fail;
10451 swig_obj[0] = args;
10452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10453 if (!SWIG_IsOK(res1)) {
10454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10455 }
10456 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 result = (wxEvtHandler *)(arg1)->GetOwner();
10460 wxPyEndAllowThreads(__tstate);
10461 if (PyErr_Occurred()) SWIG_fail;
10462 }
10463 {
10464 resultobj = wxPyMake_wxObject(result, 0);
10465 }
10466 return resultobj;
10467 fail:
10468 return NULL;
10469 }
10470
10471
10472 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj = 0;
10474 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10475 int arg2 = (int) -1 ;
10476 bool arg3 = (bool) false ;
10477 bool result;
10478 void *argp1 = 0 ;
10479 int res1 = 0 ;
10480 int val2 ;
10481 int ecode2 = 0 ;
10482 bool val3 ;
10483 int ecode3 = 0 ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 PyObject * obj2 = 0 ;
10487 char * kwnames[] = {
10488 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10489 };
10490
10491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10493 if (!SWIG_IsOK(res1)) {
10494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10495 }
10496 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10497 if (obj1) {
10498 ecode2 = SWIG_AsVal_int(obj1, &val2);
10499 if (!SWIG_IsOK(ecode2)) {
10500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10501 }
10502 arg2 = static_cast< int >(val2);
10503 }
10504 if (obj2) {
10505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10506 if (!SWIG_IsOK(ecode3)) {
10507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10508 }
10509 arg3 = static_cast< bool >(val3);
10510 }
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (bool)(arg1)->Start(arg2,arg3);
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 {
10518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10519 }
10520 return resultobj;
10521 fail:
10522 return NULL;
10523 }
10524
10525
10526 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10527 PyObject *resultobj = 0;
10528 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10529 void *argp1 = 0 ;
10530 int res1 = 0 ;
10531 PyObject *swig_obj[1] ;
10532
10533 if (!args) SWIG_fail;
10534 swig_obj[0] = args;
10535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10536 if (!SWIG_IsOK(res1)) {
10537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10538 }
10539 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 (arg1)->Stop();
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10554 PyObject *resultobj = 0;
10555 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 PyObject *swig_obj[1] ;
10559
10560 if (!args) SWIG_fail;
10561 swig_obj[0] = args;
10562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10565 }
10566 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 (arg1)->Notify();
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 resultobj = SWIG_Py_Void();
10574 return resultobj;
10575 fail:
10576 return NULL;
10577 }
10578
10579
10580 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10581 PyObject *resultobj = 0;
10582 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10583 bool result;
10584 void *argp1 = 0 ;
10585 int res1 = 0 ;
10586 PyObject *swig_obj[1] ;
10587
10588 if (!args) SWIG_fail;
10589 swig_obj[0] = args;
10590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10591 if (!SWIG_IsOK(res1)) {
10592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10593 }
10594 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10595 {
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 {
10602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10611 PyObject *resultobj = 0;
10612 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10613 int result;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 PyObject *swig_obj[1] ;
10617
10618 if (!args) SWIG_fail;
10619 swig_obj[0] = args;
10620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10623 }
10624 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 resultobj = SWIG_From_int(static_cast< int >(result));
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10639 PyObject *resultobj = 0;
10640 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10641 int result;
10642 void *argp1 = 0 ;
10643 int res1 = 0 ;
10644 PyObject *swig_obj[1] ;
10645
10646 if (!args) SWIG_fail;
10647 swig_obj[0] = args;
10648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10649 if (!SWIG_IsOK(res1)) {
10650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10651 }
10652 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10653 {
10654 PyThreadState* __tstate = wxPyBeginAllowThreads();
10655 result = (int)((wxPyTimer const *)arg1)->GetId();
10656 wxPyEndAllowThreads(__tstate);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 resultobj = SWIG_From_int(static_cast< int >(result));
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10667 PyObject *resultobj = 0;
10668 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10669 bool result;
10670 void *argp1 = 0 ;
10671 int res1 = 0 ;
10672 PyObject *swig_obj[1] ;
10673
10674 if (!args) SWIG_fail;
10675 swig_obj[0] = args;
10676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10679 }
10680 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10681 {
10682 PyThreadState* __tstate = wxPyBeginAllowThreads();
10683 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 {
10688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10689 }
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10697 PyObject *obj;
10698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10699 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10700 return SWIG_Py_Void();
10701 }
10702
10703 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704 return SWIG_Python_InitShadowInstance(args);
10705 }
10706
10707 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj = 0;
10709 int arg1 = (int) 0 ;
10710 int arg2 = (int) 0 ;
10711 wxTimerEvent *result = 0 ;
10712 int val1 ;
10713 int ecode1 = 0 ;
10714 int val2 ;
10715 int ecode2 = 0 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 char * kwnames[] = {
10719 (char *) "timerid",(char *) "interval", NULL
10720 };
10721
10722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10723 if (obj0) {
10724 ecode1 = SWIG_AsVal_int(obj0, &val1);
10725 if (!SWIG_IsOK(ecode1)) {
10726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10727 }
10728 arg1 = static_cast< int >(val1);
10729 }
10730 if (obj1) {
10731 ecode2 = SWIG_AsVal_int(obj1, &val2);
10732 if (!SWIG_IsOK(ecode2)) {
10733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10734 }
10735 arg2 = static_cast< int >(val2);
10736 }
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10740 wxPyEndAllowThreads(__tstate);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10744 return resultobj;
10745 fail:
10746 return NULL;
10747 }
10748
10749
10750 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10751 PyObject *resultobj = 0;
10752 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10753 int result;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 PyObject *swig_obj[1] ;
10757
10758 if (!args) SWIG_fail;
10759 swig_obj[0] = args;
10760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10761 if (!SWIG_IsOK(res1)) {
10762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10763 }
10764 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 resultobj = SWIG_From_int(static_cast< int >(result));
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *obj;
10780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10781 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10782 return SWIG_Py_Void();
10783 }
10784
10785 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 return SWIG_Python_InitShadowInstance(args);
10787 }
10788
10789 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10790 PyObject *resultobj = 0;
10791 wxTimer *arg1 = 0 ;
10792 wxTimerRunner *result = 0 ;
10793 void *argp1 = 0 ;
10794 int res1 = 0 ;
10795
10796 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10798 if (!SWIG_IsOK(res1)) {
10799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10800 }
10801 if (!argp1) {
10802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10803 }
10804 arg1 = reinterpret_cast< wxTimer * >(argp1);
10805 {
10806 if (!wxPyCheckForApp()) SWIG_fail;
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10820 PyObject *resultobj = 0;
10821 wxTimer *arg1 = 0 ;
10822 int arg2 ;
10823 bool arg3 = (bool) false ;
10824 wxTimerRunner *result = 0 ;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 int val2 ;
10828 int ecode2 = 0 ;
10829 bool val3 ;
10830 int ecode3 = 0 ;
10831
10832 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10834 if (!SWIG_IsOK(res1)) {
10835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10836 }
10837 if (!argp1) {
10838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10839 }
10840 arg1 = reinterpret_cast< wxTimer * >(argp1);
10841 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10842 if (!SWIG_IsOK(ecode2)) {
10843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10844 }
10845 arg2 = static_cast< int >(val2);
10846 if (swig_obj[2]) {
10847 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10848 if (!SWIG_IsOK(ecode3)) {
10849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10850 }
10851 arg3 = static_cast< bool >(val3);
10852 }
10853 {
10854 if (!wxPyCheckForApp()) SWIG_fail;
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10861 return resultobj;
10862 fail:
10863 return NULL;
10864 }
10865
10866
10867 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10868 int argc;
10869 PyObject *argv[4];
10870
10871 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10872 --argc;
10873 if (argc == 1) {
10874 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10875 }
10876 if ((argc >= 2) && (argc <= 3)) {
10877 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10878 }
10879
10880 fail:
10881 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10882 return NULL;
10883 }
10884
10885
10886 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10887 PyObject *resultobj = 0;
10888 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10889 void *argp1 = 0 ;
10890 int res1 = 0 ;
10891 PyObject *swig_obj[1] ;
10892
10893 if (!args) SWIG_fail;
10894 swig_obj[0] = args;
10895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10896 if (!SWIG_IsOK(res1)) {
10897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10898 }
10899 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 delete arg1;
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_Py_Void();
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10917 int arg2 ;
10918 bool arg3 = (bool) false ;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 int val2 ;
10922 int ecode2 = 0 ;
10923 bool val3 ;
10924 int ecode3 = 0 ;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 PyObject * obj2 = 0 ;
10928 char * kwnames[] = {
10929 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10930 };
10931
10932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10934 if (!SWIG_IsOK(res1)) {
10935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10936 }
10937 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10938 ecode2 = SWIG_AsVal_int(obj1, &val2);
10939 if (!SWIG_IsOK(ecode2)) {
10940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10941 }
10942 arg2 = static_cast< int >(val2);
10943 if (obj2) {
10944 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10945 if (!SWIG_IsOK(ecode3)) {
10946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10947 }
10948 arg3 = static_cast< bool >(val3);
10949 }
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 (arg1)->Start(arg2,arg3);
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_Py_Void();
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10964 PyObject *obj;
10965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10966 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10967 return SWIG_Py_Void();
10968 }
10969
10970 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 return SWIG_Python_InitShadowInstance(args);
10972 }
10973
10974 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10975 PyObject *resultobj = 0;
10976 wxLog *result = 0 ;
10977
10978 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 result = (wxLog *)new wxLog();
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10993 PyObject *resultobj = 0;
10994 wxLog *arg1 = (wxLog *) 0 ;
10995 void *argp1 = 0 ;
10996 int res1 = 0 ;
10997 PyObject *swig_obj[1] ;
10998
10999 if (!args) SWIG_fail;
11000 swig_obj[0] = args;
11001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11002 if (!SWIG_IsOK(res1)) {
11003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11004 }
11005 arg1 = reinterpret_cast< wxLog * >(argp1);
11006 {
11007 PyThreadState* __tstate = wxPyBeginAllowThreads();
11008 delete arg1;
11009
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 resultobj = SWIG_Py_Void();
11014 return resultobj;
11015 fail:
11016 return NULL;
11017 }
11018
11019
11020 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11021 PyObject *resultobj = 0;
11022 bool result;
11023
11024 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 result = (bool)wxLog::IsEnabled();
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 {
11032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 bool arg1 = (bool) true ;
11043 bool result;
11044 bool val1 ;
11045 int ecode1 = 0 ;
11046 PyObject * obj0 = 0 ;
11047 char * kwnames[] = {
11048 (char *) "doIt", NULL
11049 };
11050
11051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11052 if (obj0) {
11053 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11054 if (!SWIG_IsOK(ecode1)) {
11055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11056 }
11057 arg1 = static_cast< bool >(val1);
11058 }
11059 {
11060 PyThreadState* __tstate = wxPyBeginAllowThreads();
11061 result = (bool)wxLog::EnableLogging(arg1);
11062 wxPyEndAllowThreads(__tstate);
11063 if (PyErr_Occurred()) SWIG_fail;
11064 }
11065 {
11066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11067 }
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj = 0;
11076 wxLogLevel arg1 ;
11077 wxChar *arg2 = (wxChar *) 0 ;
11078 time_t arg3 ;
11079 unsigned long val1 ;
11080 int ecode1 = 0 ;
11081 void *argp2 = 0 ;
11082 int res2 = 0 ;
11083 unsigned int val3 ;
11084 int ecode3 = 0 ;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 PyObject * obj2 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "level",(char *) "szString",(char *) "t", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11093 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11094 if (!SWIG_IsOK(ecode1)) {
11095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11096 }
11097 arg1 = static_cast< wxLogLevel >(val1);
11098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11099 if (!SWIG_IsOK(res2)) {
11100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11101 }
11102 arg2 = reinterpret_cast< wxChar * >(argp2);
11103 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11104 if (!SWIG_IsOK(ecode3)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11106 }
11107 arg3 = static_cast< time_t >(val3);
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11111 wxPyEndAllowThreads(__tstate);
11112 if (PyErr_Occurred()) SWIG_fail;
11113 }
11114 resultobj = SWIG_Py_Void();
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11122 PyObject *resultobj = 0;
11123 wxLog *arg1 = (wxLog *) 0 ;
11124 void *argp1 = 0 ;
11125 int res1 = 0 ;
11126 PyObject *swig_obj[1] ;
11127
11128 if (!args) SWIG_fail;
11129 swig_obj[0] = args;
11130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11131 if (!SWIG_IsOK(res1)) {
11132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11133 }
11134 arg1 = reinterpret_cast< wxLog * >(argp1);
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 (arg1)->Flush();
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 resultobj = SWIG_Py_Void();
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11149 PyObject *resultobj = 0;
11150
11151 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 wxLog::FlushActive();
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 resultobj = SWIG_Py_Void();
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11166 PyObject *resultobj = 0;
11167 wxLog *result = 0 ;
11168
11169 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11170 {
11171 PyThreadState* __tstate = wxPyBeginAllowThreads();
11172 result = (wxLog *)wxLog::GetActiveTarget();
11173 wxPyEndAllowThreads(__tstate);
11174 if (PyErr_Occurred()) SWIG_fail;
11175 }
11176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11184 PyObject *resultobj = 0;
11185 wxLog *arg1 = (wxLog *) 0 ;
11186 wxLog *result = 0 ;
11187 int res1 = 0 ;
11188 PyObject * obj0 = 0 ;
11189 char * kwnames[] = {
11190 (char *) "pLogger", NULL
11191 };
11192
11193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11194 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11195 if (!SWIG_IsOK(res1)) {
11196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11197 }
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213
11214 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 wxLog::Suspend();
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_Py_Void();
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11229 PyObject *resultobj = 0;
11230
11231 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11232 {
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 wxLog::Resume();
11235 wxPyEndAllowThreads(__tstate);
11236 if (PyErr_Occurred()) SWIG_fail;
11237 }
11238 resultobj = SWIG_Py_Void();
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11246 PyObject *resultobj = 0;
11247 bool arg1 = (bool) true ;
11248 bool val1 ;
11249 int ecode1 = 0 ;
11250 PyObject * obj0 = 0 ;
11251 char * kwnames[] = {
11252 (char *) "bVerbose", NULL
11253 };
11254
11255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11256 if (obj0) {
11257 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11258 if (!SWIG_IsOK(ecode1)) {
11259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11260 }
11261 arg1 = static_cast< bool >(val1);
11262 }
11263 {
11264 PyThreadState* __tstate = wxPyBeginAllowThreads();
11265 wxLog::SetVerbose(arg1);
11266 wxPyEndAllowThreads(__tstate);
11267 if (PyErr_Occurred()) SWIG_fail;
11268 }
11269 resultobj = SWIG_Py_Void();
11270 return resultobj;
11271 fail:
11272 return NULL;
11273 }
11274
11275
11276 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11277 PyObject *resultobj = 0;
11278 wxLogLevel arg1 ;
11279 unsigned long val1 ;
11280 int ecode1 = 0 ;
11281 PyObject * obj0 = 0 ;
11282 char * kwnames[] = {
11283 (char *) "logLevel", NULL
11284 };
11285
11286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11287 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11288 if (!SWIG_IsOK(ecode1)) {
11289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11290 }
11291 arg1 = static_cast< wxLogLevel >(val1);
11292 {
11293 PyThreadState* __tstate = wxPyBeginAllowThreads();
11294 wxLog::SetLogLevel(arg1);
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_Py_Void();
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11306 PyObject *resultobj = 0;
11307
11308 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11309 {
11310 PyThreadState* __tstate = wxPyBeginAllowThreads();
11311 wxLog::DontCreateOnDemand();
11312 wxPyEndAllowThreads(__tstate);
11313 if (PyErr_Occurred()) SWIG_fail;
11314 }
11315 resultobj = SWIG_Py_Void();
11316 return resultobj;
11317 fail:
11318 return NULL;
11319 }
11320
11321
11322 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj = 0;
11324 wxTraceMask arg1 ;
11325 unsigned long val1 ;
11326 int ecode1 = 0 ;
11327 PyObject * obj0 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "ulMask", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11333 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11334 if (!SWIG_IsOK(ecode1)) {
11335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11336 }
11337 arg1 = static_cast< wxTraceMask >(val1);
11338 {
11339 PyThreadState* __tstate = wxPyBeginAllowThreads();
11340 wxLog::SetTraceMask(arg1);
11341 wxPyEndAllowThreads(__tstate);
11342 if (PyErr_Occurred()) SWIG_fail;
11343 }
11344 resultobj = SWIG_Py_Void();
11345 return resultobj;
11346 fail:
11347 return NULL;
11348 }
11349
11350
11351 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11352 PyObject *resultobj = 0;
11353 wxString *arg1 = 0 ;
11354 bool temp1 = false ;
11355 PyObject * obj0 = 0 ;
11356 char * kwnames[] = {
11357 (char *) "str", NULL
11358 };
11359
11360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11361 {
11362 arg1 = wxString_in_helper(obj0);
11363 if (arg1 == NULL) SWIG_fail;
11364 temp1 = true;
11365 }
11366 {
11367 PyThreadState* __tstate = wxPyBeginAllowThreads();
11368 wxLog::AddTraceMask((wxString const &)*arg1);
11369 wxPyEndAllowThreads(__tstate);
11370 if (PyErr_Occurred()) SWIG_fail;
11371 }
11372 resultobj = SWIG_Py_Void();
11373 {
11374 if (temp1)
11375 delete arg1;
11376 }
11377 return resultobj;
11378 fail:
11379 {
11380 if (temp1)
11381 delete arg1;
11382 }
11383 return NULL;
11384 }
11385
11386
11387 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11388 PyObject *resultobj = 0;
11389 wxString *arg1 = 0 ;
11390 bool temp1 = false ;
11391 PyObject * obj0 = 0 ;
11392 char * kwnames[] = {
11393 (char *) "str", NULL
11394 };
11395
11396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11397 {
11398 arg1 = wxString_in_helper(obj0);
11399 if (arg1 == NULL) SWIG_fail;
11400 temp1 = true;
11401 }
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 wxLog::RemoveTraceMask((wxString const &)*arg1);
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 resultobj = SWIG_Py_Void();
11409 {
11410 if (temp1)
11411 delete arg1;
11412 }
11413 return resultobj;
11414 fail:
11415 {
11416 if (temp1)
11417 delete arg1;
11418 }
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11424 PyObject *resultobj = 0;
11425
11426 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 wxLog::ClearTraceMasks();
11430 wxPyEndAllowThreads(__tstate);
11431 if (PyErr_Occurred()) SWIG_fail;
11432 }
11433 resultobj = SWIG_Py_Void();
11434 return resultobj;
11435 fail:
11436 return NULL;
11437 }
11438
11439
11440 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11441 PyObject *resultobj = 0;
11442 wxArrayString *result = 0 ;
11443
11444 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 {
11448 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11449 result = (wxArrayString *) &_result_ref;
11450 }
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 {
11455 resultobj = wxArrayString2PyList_helper(*result);
11456 }
11457 return resultobj;
11458 fail:
11459 return NULL;
11460 }
11461
11462
11463 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj = 0;
11465 wxChar *arg1 = (wxChar *) 0 ;
11466 void *argp1 = 0 ;
11467 int res1 = 0 ;
11468 PyObject * obj0 = 0 ;
11469 char * kwnames[] = {
11470 (char *) "ts", NULL
11471 };
11472
11473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11475 if (!SWIG_IsOK(res1)) {
11476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11477 }
11478 arg1 = reinterpret_cast< wxChar * >(argp1);
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 wxLog::SetTimestamp((wxChar const *)arg1);
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 resultobj = SWIG_Py_Void();
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11493 PyObject *resultobj = 0;
11494 bool result;
11495
11496 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11497 {
11498 PyThreadState* __tstate = wxPyBeginAllowThreads();
11499 result = (bool)wxLog::GetVerbose();
11500 wxPyEndAllowThreads(__tstate);
11501 if (PyErr_Occurred()) SWIG_fail;
11502 }
11503 {
11504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11505 }
11506 return resultobj;
11507 fail:
11508 return NULL;
11509 }
11510
11511
11512 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11513 PyObject *resultobj = 0;
11514 wxTraceMask result;
11515
11516 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 result = (wxTraceMask)wxLog::GetTraceMask();
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = 0;
11532 wxChar *arg1 = (wxChar *) 0 ;
11533 bool result;
11534 void *argp1 = 0 ;
11535 int res1 = 0 ;
11536 PyObject * obj0 = 0 ;
11537 char * kwnames[] = {
11538 (char *) "mask", NULL
11539 };
11540
11541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11543 if (!SWIG_IsOK(res1)) {
11544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11545 }
11546 arg1 = reinterpret_cast< wxChar * >(argp1);
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11563 PyObject *resultobj = 0;
11564 wxLogLevel result;
11565
11566 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = (wxLogLevel)wxLog::GetLogLevel();
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11581 PyObject *resultobj = 0;
11582 wxChar *result = 0 ;
11583
11584 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11585 {
11586 PyThreadState* __tstate = wxPyBeginAllowThreads();
11587 result = (wxChar *)wxLog::GetTimestamp();
11588 wxPyEndAllowThreads(__tstate);
11589 if (PyErr_Occurred()) SWIG_fail;
11590 }
11591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11592 return resultobj;
11593 fail:
11594 return NULL;
11595 }
11596
11597
11598 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11599 PyObject *resultobj = 0;
11600 wxString result;
11601
11602 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = wxLog_TimeStamp();
11606 wxPyEndAllowThreads(__tstate);
11607 if (PyErr_Occurred()) SWIG_fail;
11608 }
11609 {
11610 #if wxUSE_UNICODE
11611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11612 #else
11613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11614 #endif
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxLog *arg1 = (wxLog *) 0 ;
11625 void *argp1 = 0 ;
11626 int res1 = 0 ;
11627 PyObject *swig_obj[1] ;
11628
11629 if (!args) SWIG_fail;
11630 swig_obj[0] = args;
11631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11632 if (!SWIG_IsOK(res1)) {
11633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11634 }
11635 arg1 = reinterpret_cast< wxLog * >(argp1);
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 wxLog_Destroy(arg1);
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 resultobj = SWIG_Py_Void();
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11650 PyObject *obj;
11651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11652 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11653 return SWIG_Py_Void();
11654 }
11655
11656 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 return SWIG_Python_InitShadowInstance(args);
11658 }
11659
11660 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661 PyObject *resultobj = 0;
11662 wxLogStderr *result = 0 ;
11663
11664 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxLogStderr *)new wxLogStderr();
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *obj;
11680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11681 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11682 return SWIG_Py_Void();
11683 }
11684
11685 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 return SWIG_Python_InitShadowInstance(args);
11687 }
11688
11689 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11692 wxLogTextCtrl *result = 0 ;
11693 void *argp1 = 0 ;
11694 int res1 = 0 ;
11695 PyObject * obj0 = 0 ;
11696 char * kwnames[] = {
11697 (char *) "pTextCtrl", NULL
11698 };
11699
11700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11702 if (!SWIG_IsOK(res1)) {
11703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11704 }
11705 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720 PyObject *obj;
11721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11722 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11723 return SWIG_Py_Void();
11724 }
11725
11726 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 return SWIG_Python_InitShadowInstance(args);
11728 }
11729
11730 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11731 PyObject *resultobj = 0;
11732 wxLogGui *result = 0 ;
11733
11734 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (wxLogGui *)new wxLogGui();
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11749 PyObject *obj;
11750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11751 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11752 return SWIG_Py_Void();
11753 }
11754
11755 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11756 return SWIG_Python_InitShadowInstance(args);
11757 }
11758
11759 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj = 0;
11761 wxFrame *arg1 = (wxFrame *) 0 ;
11762 wxString *arg2 = 0 ;
11763 bool arg3 = (bool) true ;
11764 bool arg4 = (bool) true ;
11765 wxLogWindow *result = 0 ;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 bool temp2 = false ;
11769 bool val3 ;
11770 int ecode3 = 0 ;
11771 bool val4 ;
11772 int ecode4 = 0 ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 PyObject * obj2 = 0 ;
11776 PyObject * obj3 = 0 ;
11777 char * kwnames[] = {
11778 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11779 };
11780
11781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11783 if (!SWIG_IsOK(res1)) {
11784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11785 }
11786 arg1 = reinterpret_cast< wxFrame * >(argp1);
11787 {
11788 arg2 = wxString_in_helper(obj1);
11789 if (arg2 == NULL) SWIG_fail;
11790 temp2 = true;
11791 }
11792 if (obj2) {
11793 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11794 if (!SWIG_IsOK(ecode3)) {
11795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11796 }
11797 arg3 = static_cast< bool >(val3);
11798 }
11799 if (obj3) {
11800 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11801 if (!SWIG_IsOK(ecode4)) {
11802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11803 }
11804 arg4 = static_cast< bool >(val4);
11805 }
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11813 {
11814 if (temp2)
11815 delete arg2;
11816 }
11817 return resultobj;
11818 fail:
11819 {
11820 if (temp2)
11821 delete arg2;
11822 }
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj = 0;
11829 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11830 bool arg2 = (bool) true ;
11831 void *argp1 = 0 ;
11832 int res1 = 0 ;
11833 bool val2 ;
11834 int ecode2 = 0 ;
11835 PyObject * obj0 = 0 ;
11836 PyObject * obj1 = 0 ;
11837 char * kwnames[] = {
11838 (char *) "self",(char *) "bShow", NULL
11839 };
11840
11841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11843 if (!SWIG_IsOK(res1)) {
11844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11845 }
11846 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11847 if (obj1) {
11848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11849 if (!SWIG_IsOK(ecode2)) {
11850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11851 }
11852 arg2 = static_cast< bool >(val2);
11853 }
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 (arg1)->Show(arg2);
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 resultobj = SWIG_Py_Void();
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11868 PyObject *resultobj = 0;
11869 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11870 wxFrame *result = 0 ;
11871 void *argp1 = 0 ;
11872 int res1 = 0 ;
11873 PyObject *swig_obj[1] ;
11874
11875 if (!args) SWIG_fail;
11876 swig_obj[0] = args;
11877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11878 if (!SWIG_IsOK(res1)) {
11879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11880 }
11881 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 {
11889 resultobj = wxPyMake_wxObject(result, (bool)0);
11890 }
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11898 PyObject *resultobj = 0;
11899 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11900 wxLog *result = 0 ;
11901 void *argp1 = 0 ;
11902 int res1 = 0 ;
11903 PyObject *swig_obj[1] ;
11904
11905 if (!args) SWIG_fail;
11906 swig_obj[0] = args;
11907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11910 }
11911 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11919 return resultobj;
11920 fail:
11921 return NULL;
11922 }
11923
11924
11925 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11926 PyObject *resultobj = 0;
11927 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11928 bool result;
11929 void *argp1 = 0 ;
11930 int res1 = 0 ;
11931 PyObject *swig_obj[1] ;
11932
11933 if (!args) SWIG_fail;
11934 swig_obj[0] = args;
11935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11936 if (!SWIG_IsOK(res1)) {
11937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11938 }
11939 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 {
11947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11948 }
11949 return resultobj;
11950 fail:
11951 return NULL;
11952 }
11953
11954
11955 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11956 PyObject *resultobj = 0;
11957 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11958 bool arg2 ;
11959 void *argp1 = 0 ;
11960 int res1 = 0 ;
11961 bool val2 ;
11962 int ecode2 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "bDoPass", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11973 }
11974 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11975 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11978 }
11979 arg2 = static_cast< bool >(val2);
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 (arg1)->PassMessages(arg2);
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 resultobj = SWIG_Py_Void();
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11994 PyObject *obj;
11995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11996 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11997 return SWIG_Py_Void();
11998 }
11999
12000 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 return SWIG_Python_InitShadowInstance(args);
12002 }
12003
12004 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12005 PyObject *resultobj = 0;
12006 wxLog *arg1 = (wxLog *) 0 ;
12007 wxLogChain *result = 0 ;
12008 void *argp1 = 0 ;
12009 int res1 = 0 ;
12010 PyObject * obj0 = 0 ;
12011 char * kwnames[] = {
12012 (char *) "logger", NULL
12013 };
12014
12015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12019 }
12020 arg1 = reinterpret_cast< wxLog * >(argp1);
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (wxLogChain *)new wxLogChain(arg1);
12024 wxPyEndAllowThreads(__tstate);
12025 if (PyErr_Occurred()) SWIG_fail;
12026 }
12027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12028 return resultobj;
12029 fail:
12030 return NULL;
12031 }
12032
12033
12034 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12035 PyObject *resultobj = 0;
12036 wxLogChain *arg1 = (wxLogChain *) 0 ;
12037 wxLog *arg2 = (wxLog *) 0 ;
12038 void *argp1 = 0 ;
12039 int res1 = 0 ;
12040 void *argp2 = 0 ;
12041 int res2 = 0 ;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 char * kwnames[] = {
12045 (char *) "self",(char *) "logger", NULL
12046 };
12047
12048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12050 if (!SWIG_IsOK(res1)) {
12051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12052 }
12053 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12055 if (!SWIG_IsOK(res2)) {
12056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12057 }
12058 arg2 = reinterpret_cast< wxLog * >(argp2);
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 (arg1)->SetLog(arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj = 0;
12074 wxLogChain *arg1 = (wxLogChain *) 0 ;
12075 bool arg2 ;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 bool val2 ;
12079 int ecode2 = 0 ;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char * kwnames[] = {
12083 (char *) "self",(char *) "bDoPass", NULL
12084 };
12085
12086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12088 if (!SWIG_IsOK(res1)) {
12089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12090 }
12091 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12093 if (!SWIG_IsOK(ecode2)) {
12094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12095 }
12096 arg2 = static_cast< bool >(val2);
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 (arg1)->PassMessages(arg2);
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_Py_Void();
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12111 PyObject *resultobj = 0;
12112 wxLogChain *arg1 = (wxLogChain *) 0 ;
12113 bool result;
12114 void *argp1 = 0 ;
12115 int res1 = 0 ;
12116 PyObject *swig_obj[1] ;
12117
12118 if (!args) SWIG_fail;
12119 swig_obj[0] = args;
12120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12123 }
12124 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 result = (bool)(arg1)->IsPassingMessages();
12128 wxPyEndAllowThreads(__tstate);
12129 if (PyErr_Occurred()) SWIG_fail;
12130 }
12131 {
12132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12133 }
12134 return resultobj;
12135 fail:
12136 return NULL;
12137 }
12138
12139
12140 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12141 PyObject *resultobj = 0;
12142 wxLogChain *arg1 = (wxLogChain *) 0 ;
12143 wxLog *result = 0 ;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 PyObject *swig_obj[1] ;
12147
12148 if (!args) SWIG_fail;
12149 swig_obj[0] = args;
12150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12153 }
12154 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxLog *)(arg1)->GetOldLog();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12169 PyObject *obj;
12170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12171 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12172 return SWIG_Py_Void();
12173 }
12174
12175 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12176 return SWIG_Python_InitShadowInstance(args);
12177 }
12178
12179 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12180 PyObject *resultobj = 0;
12181 wxLogBuffer *result = 0 ;
12182
12183 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 result = (wxLogBuffer *)new wxLogBuffer();
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12198 PyObject *resultobj = 0;
12199 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12200 wxString *result = 0 ;
12201 void *argp1 = 0 ;
12202 int res1 = 0 ;
12203 PyObject *swig_obj[1] ;
12204
12205 if (!args) SWIG_fail;
12206 swig_obj[0] = args;
12207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12208 if (!SWIG_IsOK(res1)) {
12209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12210 }
12211 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 {
12215 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12216 result = (wxString *) &_result_ref;
12217 }
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 #if wxUSE_UNICODE
12223 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12224 #else
12225 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12226 #endif
12227 }
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12235 PyObject *obj;
12236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12237 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12238 return SWIG_Py_Void();
12239 }
12240
12241 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12242 return SWIG_Python_InitShadowInstance(args);
12243 }
12244
12245 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12246 PyObject *resultobj = 0;
12247 unsigned long result;
12248
12249 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (unsigned long)wxSysErrorCode();
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 unsigned long arg1 = (unsigned long) 0 ;
12266 wxString result;
12267 unsigned long val1 ;
12268 int ecode1 = 0 ;
12269 PyObject * obj0 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "nErrCode", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12275 if (obj0) {
12276 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12277 if (!SWIG_IsOK(ecode1)) {
12278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12279 }
12280 arg1 = static_cast< unsigned long >(val1);
12281 }
12282 {
12283 PyThreadState* __tstate = wxPyBeginAllowThreads();
12284 result = wxSysErrorMsg(arg1);
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 {
12289 #if wxUSE_UNICODE
12290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12291 #else
12292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12293 #endif
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj = 0;
12303 wxString *arg1 = 0 ;
12304 bool temp1 = false ;
12305 PyObject * obj0 = 0 ;
12306 char * kwnames[] = {
12307 (char *) "msg", NULL
12308 };
12309
12310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12311 {
12312 arg1 = wxString_in_helper(obj0);
12313 if (arg1 == NULL) SWIG_fail;
12314 temp1 = true;
12315 }
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 wxPyLogFatalError((wxString const &)*arg1);
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 resultobj = SWIG_Py_Void();
12323 {
12324 if (temp1)
12325 delete arg1;
12326 }
12327 return resultobj;
12328 fail:
12329 {
12330 if (temp1)
12331 delete arg1;
12332 }
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 wxString *arg1 = 0 ;
12340 bool temp1 = false ;
12341 PyObject * obj0 = 0 ;
12342 char * kwnames[] = {
12343 (char *) "msg", NULL
12344 };
12345
12346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12347 {
12348 arg1 = wxString_in_helper(obj0);
12349 if (arg1 == NULL) SWIG_fail;
12350 temp1 = true;
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 wxPyLogError((wxString const &)*arg1);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 {
12360 if (temp1)
12361 delete arg1;
12362 }
12363 return resultobj;
12364 fail:
12365 {
12366 if (temp1)
12367 delete arg1;
12368 }
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj = 0;
12375 wxString *arg1 = 0 ;
12376 bool temp1 = false ;
12377 PyObject * obj0 = 0 ;
12378 char * kwnames[] = {
12379 (char *) "msg", NULL
12380 };
12381
12382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12383 {
12384 arg1 = wxString_in_helper(obj0);
12385 if (arg1 == NULL) SWIG_fail;
12386 temp1 = true;
12387 }
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 wxPyLogWarning((wxString const &)*arg1);
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 resultobj = SWIG_Py_Void();
12395 {
12396 if (temp1)
12397 delete arg1;
12398 }
12399 return resultobj;
12400 fail:
12401 {
12402 if (temp1)
12403 delete arg1;
12404 }
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12410 PyObject *resultobj = 0;
12411 wxString *arg1 = 0 ;
12412 bool temp1 = false ;
12413 PyObject * obj0 = 0 ;
12414 char * kwnames[] = {
12415 (char *) "msg", NULL
12416 };
12417
12418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12419 {
12420 arg1 = wxString_in_helper(obj0);
12421 if (arg1 == NULL) SWIG_fail;
12422 temp1 = true;
12423 }
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 wxPyLogMessage((wxString const &)*arg1);
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_Py_Void();
12431 {
12432 if (temp1)
12433 delete arg1;
12434 }
12435 return resultobj;
12436 fail:
12437 {
12438 if (temp1)
12439 delete arg1;
12440 }
12441 return NULL;
12442 }
12443
12444
12445 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12446 PyObject *resultobj = 0;
12447 wxString *arg1 = 0 ;
12448 bool temp1 = false ;
12449 PyObject * obj0 = 0 ;
12450 char * kwnames[] = {
12451 (char *) "msg", NULL
12452 };
12453
12454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12455 {
12456 arg1 = wxString_in_helper(obj0);
12457 if (arg1 == NULL) SWIG_fail;
12458 temp1 = true;
12459 }
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 wxPyLogInfo((wxString const &)*arg1);
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 resultobj = SWIG_Py_Void();
12467 {
12468 if (temp1)
12469 delete arg1;
12470 }
12471 return resultobj;
12472 fail:
12473 {
12474 if (temp1)
12475 delete arg1;
12476 }
12477 return NULL;
12478 }
12479
12480
12481 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12482 PyObject *resultobj = 0;
12483 wxString *arg1 = 0 ;
12484 bool temp1 = false ;
12485 PyObject * obj0 = 0 ;
12486 char * kwnames[] = {
12487 (char *) "msg", NULL
12488 };
12489
12490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12491 {
12492 arg1 = wxString_in_helper(obj0);
12493 if (arg1 == NULL) SWIG_fail;
12494 temp1 = true;
12495 }
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 wxPyLogDebug((wxString const &)*arg1);
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 resultobj = SWIG_Py_Void();
12503 {
12504 if (temp1)
12505 delete arg1;
12506 }
12507 return resultobj;
12508 fail:
12509 {
12510 if (temp1)
12511 delete arg1;
12512 }
12513 return NULL;
12514 }
12515
12516
12517 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj = 0;
12519 wxString *arg1 = 0 ;
12520 bool temp1 = false ;
12521 PyObject * obj0 = 0 ;
12522 char * kwnames[] = {
12523 (char *) "msg", NULL
12524 };
12525
12526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12527 {
12528 arg1 = wxString_in_helper(obj0);
12529 if (arg1 == NULL) SWIG_fail;
12530 temp1 = true;
12531 }
12532 {
12533 PyThreadState* __tstate = wxPyBeginAllowThreads();
12534 wxPyLogVerbose((wxString const &)*arg1);
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 resultobj = SWIG_Py_Void();
12539 {
12540 if (temp1)
12541 delete arg1;
12542 }
12543 return resultobj;
12544 fail:
12545 {
12546 if (temp1)
12547 delete arg1;
12548 }
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj = 0;
12555 wxString *arg1 = 0 ;
12556 bool temp1 = false ;
12557 PyObject * obj0 = 0 ;
12558 char * kwnames[] = {
12559 (char *) "msg", NULL
12560 };
12561
12562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12563 {
12564 arg1 = wxString_in_helper(obj0);
12565 if (arg1 == NULL) SWIG_fail;
12566 temp1 = true;
12567 }
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 wxPyLogStatus((wxString const &)*arg1);
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 resultobj = SWIG_Py_Void();
12575 {
12576 if (temp1)
12577 delete arg1;
12578 }
12579 return resultobj;
12580 fail:
12581 {
12582 if (temp1)
12583 delete arg1;
12584 }
12585 return NULL;
12586 }
12587
12588
12589 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12590 PyObject *resultobj = 0;
12591 wxFrame *arg1 = (wxFrame *) 0 ;
12592 wxString *arg2 = 0 ;
12593 void *argp1 = 0 ;
12594 int res1 = 0 ;
12595 bool temp2 = false ;
12596 PyObject * obj0 = 0 ;
12597 PyObject * obj1 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "pFrame",(char *) "msg", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12606 }
12607 arg1 = reinterpret_cast< wxFrame * >(argp1);
12608 {
12609 arg2 = wxString_in_helper(obj1);
12610 if (arg2 == NULL) SWIG_fail;
12611 temp2 = true;
12612 }
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 resultobj = SWIG_Py_Void();
12620 {
12621 if (temp2)
12622 delete arg2;
12623 }
12624 return resultobj;
12625 fail:
12626 {
12627 if (temp2)
12628 delete arg2;
12629 }
12630 return NULL;
12631 }
12632
12633
12634 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 wxString *arg1 = 0 ;
12637 bool temp1 = false ;
12638 PyObject * obj0 = 0 ;
12639 char * kwnames[] = {
12640 (char *) "msg", NULL
12641 };
12642
12643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12644 {
12645 arg1 = wxString_in_helper(obj0);
12646 if (arg1 == NULL) SWIG_fail;
12647 temp1 = true;
12648 }
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 wxPyLogSysError((wxString const &)*arg1);
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 resultobj = SWIG_Py_Void();
12656 {
12657 if (temp1)
12658 delete arg1;
12659 }
12660 return resultobj;
12661 fail:
12662 {
12663 if (temp1)
12664 delete arg1;
12665 }
12666 return NULL;
12667 }
12668
12669
12670 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12671 PyObject *resultobj = 0;
12672 unsigned long arg1 ;
12673 wxString *arg2 = 0 ;
12674 unsigned long val1 ;
12675 int ecode1 = 0 ;
12676 bool temp2 = false ;
12677 PyObject * obj0 = 0 ;
12678 PyObject * obj1 = 0 ;
12679 char * kwnames[] = {
12680 (char *) "level",(char *) "msg", NULL
12681 };
12682
12683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12684 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12685 if (!SWIG_IsOK(ecode1)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12687 }
12688 arg1 = static_cast< unsigned long >(val1);
12689 {
12690 arg2 = wxString_in_helper(obj1);
12691 if (arg2 == NULL) SWIG_fail;
12692 temp2 = true;
12693 }
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12697 wxPyEndAllowThreads(__tstate);
12698 if (PyErr_Occurred()) SWIG_fail;
12699 }
12700 resultobj = SWIG_Py_Void();
12701 {
12702 if (temp2)
12703 delete arg2;
12704 }
12705 return resultobj;
12706 fail:
12707 {
12708 if (temp2)
12709 delete arg2;
12710 }
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12716 PyObject *resultobj = 0;
12717 unsigned long arg1 ;
12718 wxString *arg2 = 0 ;
12719 unsigned long val1 ;
12720 int ecode1 = 0 ;
12721 bool temp2 = false ;
12722
12723 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12724 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12725 if (!SWIG_IsOK(ecode1)) {
12726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12727 }
12728 arg1 = static_cast< unsigned long >(val1);
12729 {
12730 arg2 = wxString_in_helper(swig_obj[1]);
12731 if (arg2 == NULL) SWIG_fail;
12732 temp2 = true;
12733 }
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 wxPyLogTrace(arg1,(wxString const &)*arg2);
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 resultobj = SWIG_Py_Void();
12741 {
12742 if (temp2)
12743 delete arg2;
12744 }
12745 return resultobj;
12746 fail:
12747 {
12748 if (temp2)
12749 delete arg2;
12750 }
12751 return NULL;
12752 }
12753
12754
12755 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12756 PyObject *resultobj = 0;
12757 wxString *arg1 = 0 ;
12758 wxString *arg2 = 0 ;
12759 bool temp1 = false ;
12760 bool temp2 = false ;
12761
12762 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12763 {
12764 arg1 = wxString_in_helper(swig_obj[0]);
12765 if (arg1 == NULL) SWIG_fail;
12766 temp1 = true;
12767 }
12768 {
12769 arg2 = wxString_in_helper(swig_obj[1]);
12770 if (arg2 == NULL) SWIG_fail;
12771 temp2 = true;
12772 }
12773 {
12774 PyThreadState* __tstate = wxPyBeginAllowThreads();
12775 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12776 wxPyEndAllowThreads(__tstate);
12777 if (PyErr_Occurred()) SWIG_fail;
12778 }
12779 resultobj = SWIG_Py_Void();
12780 {
12781 if (temp1)
12782 delete arg1;
12783 }
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 return resultobj;
12789 fail:
12790 {
12791 if (temp1)
12792 delete arg1;
12793 }
12794 {
12795 if (temp2)
12796 delete arg2;
12797 }
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12803 int argc;
12804 PyObject *argv[3];
12805
12806 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12807 --argc;
12808 if (argc == 2) {
12809 int _v = 0;
12810 {
12811 {
12812 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12813 }
12814 }
12815 if (!_v) goto check_1;
12816 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12817 }
12818 check_1:
12819
12820 if (argc == 2) {
12821 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12822 }
12823
12824 fail:
12825 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12826 return NULL;
12827 }
12828
12829
12830 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj = 0;
12832 wxString *arg1 = 0 ;
12833 wxString *arg2 = 0 ;
12834 bool temp1 = false ;
12835 bool temp2 = false ;
12836 PyObject * obj0 = 0 ;
12837 PyObject * obj1 = 0 ;
12838 char * kwnames[] = {
12839 (char *) "title",(char *) "text", NULL
12840 };
12841
12842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12843 {
12844 arg1 = wxString_in_helper(obj0);
12845 if (arg1 == NULL) SWIG_fail;
12846 temp1 = true;
12847 }
12848 {
12849 arg2 = wxString_in_helper(obj1);
12850 if (arg2 == NULL) SWIG_fail;
12851 temp2 = true;
12852 }
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 resultobj = SWIG_Py_Void();
12860 {
12861 if (temp1)
12862 delete arg1;
12863 }
12864 {
12865 if (temp2)
12866 delete arg2;
12867 }
12868 return resultobj;
12869 fail:
12870 {
12871 if (temp1)
12872 delete arg1;
12873 }
12874 {
12875 if (temp2)
12876 delete arg2;
12877 }
12878 return NULL;
12879 }
12880
12881
12882 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 PyObject *resultobj = 0;
12884 wxLogNull *result = 0 ;
12885
12886 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 result = (wxLogNull *)new wxLogNull();
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12894 return resultobj;
12895 fail:
12896 return NULL;
12897 }
12898
12899
12900 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12901 PyObject *resultobj = 0;
12902 wxLogNull *arg1 = (wxLogNull *) 0 ;
12903 void *argp1 = 0 ;
12904 int res1 = 0 ;
12905 PyObject *swig_obj[1] ;
12906
12907 if (!args) SWIG_fail;
12908 swig_obj[0] = args;
12909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12910 if (!SWIG_IsOK(res1)) {
12911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12912 }
12913 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12914 {
12915 PyThreadState* __tstate = wxPyBeginAllowThreads();
12916 delete arg1;
12917
12918 wxPyEndAllowThreads(__tstate);
12919 if (PyErr_Occurred()) SWIG_fail;
12920 }
12921 resultobj = SWIG_Py_Void();
12922 return resultobj;
12923 fail:
12924 return NULL;
12925 }
12926
12927
12928 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12929 PyObject *obj;
12930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12931 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12932 return SWIG_Py_Void();
12933 }
12934
12935 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12936 return SWIG_Python_InitShadowInstance(args);
12937 }
12938
12939 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12940 PyObject *resultobj = 0;
12941 wxPyLog *result = 0 ;
12942
12943 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12944 {
12945 PyThreadState* __tstate = wxPyBeginAllowThreads();
12946 result = (wxPyLog *)new wxPyLog();
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12951 return resultobj;
12952 fail:
12953 return NULL;
12954 }
12955
12956
12957 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12958 PyObject *resultobj = 0;
12959 wxPyLog *arg1 = (wxPyLog *) 0 ;
12960 PyObject *arg2 = (PyObject *) 0 ;
12961 PyObject *arg3 = (PyObject *) 0 ;
12962 void *argp1 = 0 ;
12963 int res1 = 0 ;
12964 PyObject * obj0 = 0 ;
12965 PyObject * obj1 = 0 ;
12966 PyObject * obj2 = 0 ;
12967 char * kwnames[] = {
12968 (char *) "self",(char *) "self",(char *) "_class", NULL
12969 };
12970
12971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12973 if (!SWIG_IsOK(res1)) {
12974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12975 }
12976 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12977 arg2 = obj1;
12978 arg3 = obj2;
12979 {
12980 PyThreadState* __tstate = wxPyBeginAllowThreads();
12981 (arg1)->_setCallbackInfo(arg2,arg3);
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 resultobj = SWIG_Py_Void();
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 PyObject *obj;
12994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12995 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12996 return SWIG_Py_Void();
12997 }
12998
12999 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 return SWIG_Python_InitShadowInstance(args);
13001 }
13002
13003 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13004 PyObject *resultobj = 0;
13005 int arg1 ;
13006 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13007 int arg3 = (int) wxKILL_NOCHILDREN ;
13008 wxKillError result;
13009 int val1 ;
13010 int ecode1 = 0 ;
13011 int val2 ;
13012 int ecode2 = 0 ;
13013 int val3 ;
13014 int ecode3 = 0 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 char * kwnames[] = {
13019 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13020 };
13021
13022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13023 ecode1 = SWIG_AsVal_int(obj0, &val1);
13024 if (!SWIG_IsOK(ecode1)) {
13025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13026 }
13027 arg1 = static_cast< int >(val1);
13028 if (obj1) {
13029 ecode2 = SWIG_AsVal_int(obj1, &val2);
13030 if (!SWIG_IsOK(ecode2)) {
13031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13032 }
13033 arg2 = static_cast< wxSignal >(val2);
13034 }
13035 if (obj2) {
13036 ecode3 = SWIG_AsVal_int(obj2, &val3);
13037 if (!SWIG_IsOK(ecode3)) {
13038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13039 }
13040 arg3 = static_cast< int >(val3);
13041 }
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13045 wxPyEndAllowThreads(__tstate);
13046 if (PyErr_Occurred()) SWIG_fail;
13047 }
13048 resultobj = SWIG_From_int(static_cast< int >(result));
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj = 0;
13057 int arg1 ;
13058 bool result;
13059 int val1 ;
13060 int ecode1 = 0 ;
13061 PyObject * obj0 = 0 ;
13062 char * kwnames[] = {
13063 (char *) "pid", NULL
13064 };
13065
13066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13067 ecode1 = SWIG_AsVal_int(obj0, &val1);
13068 if (!SWIG_IsOK(ecode1)) {
13069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13070 }
13071 arg1 = static_cast< int >(val1);
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 result = (bool)wxPyProcess::Exists(arg1);
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 {
13079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13080 }
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj = 0;
13089 wxString *arg1 = 0 ;
13090 int arg2 = (int) wxEXEC_ASYNC ;
13091 wxPyProcess *result = 0 ;
13092 bool temp1 = false ;
13093 int val2 ;
13094 int ecode2 = 0 ;
13095 PyObject * obj0 = 0 ;
13096 PyObject * obj1 = 0 ;
13097 char * kwnames[] = {
13098 (char *) "cmd",(char *) "flags", NULL
13099 };
13100
13101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13102 {
13103 arg1 = wxString_in_helper(obj0);
13104 if (arg1 == NULL) SWIG_fail;
13105 temp1 = true;
13106 }
13107 if (obj1) {
13108 ecode2 = SWIG_AsVal_int(obj1, &val2);
13109 if (!SWIG_IsOK(ecode2)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13111 }
13112 arg2 = static_cast< int >(val2);
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13121 {
13122 if (temp1)
13123 delete arg1;
13124 }
13125 return resultobj;
13126 fail:
13127 {
13128 if (temp1)
13129 delete arg1;
13130 }
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = 0;
13137 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13138 int arg2 = (int) -1 ;
13139 wxPyProcess *result = 0 ;
13140 void *argp1 = 0 ;
13141 int res1 = 0 ;
13142 int val2 ;
13143 int ecode2 = 0 ;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char * kwnames[] = {
13147 (char *) "parent",(char *) "id", NULL
13148 };
13149
13150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13151 if (obj0) {
13152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13153 if (!SWIG_IsOK(res1)) {
13154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13155 }
13156 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13157 }
13158 if (obj1) {
13159 ecode2 = SWIG_AsVal_int(obj1, &val2);
13160 if (!SWIG_IsOK(ecode2)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13162 }
13163 arg2 = static_cast< int >(val2);
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj = 0;
13180 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13181 PyObject *arg2 = (PyObject *) 0 ;
13182 PyObject *arg3 = (PyObject *) 0 ;
13183 void *argp1 = 0 ;
13184 int res1 = 0 ;
13185 PyObject * obj0 = 0 ;
13186 PyObject * obj1 = 0 ;
13187 PyObject * obj2 = 0 ;
13188 char * kwnames[] = {
13189 (char *) "self",(char *) "self",(char *) "_class", NULL
13190 };
13191
13192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13194 if (!SWIG_IsOK(res1)) {
13195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13196 }
13197 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13198 arg2 = obj1;
13199 arg3 = obj2;
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 (arg1)->_setCallbackInfo(arg2,arg3);
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 resultobj = SWIG_Py_Void();
13207 return resultobj;
13208 fail:
13209 return NULL;
13210 }
13211
13212
13213 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13214 PyObject *resultobj = 0;
13215 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13216 int arg2 ;
13217 int arg3 ;
13218 void *argp1 = 0 ;
13219 int res1 = 0 ;
13220 int val2 ;
13221 int ecode2 = 0 ;
13222 int val3 ;
13223 int ecode3 = 0 ;
13224 PyObject * obj0 = 0 ;
13225 PyObject * obj1 = 0 ;
13226 PyObject * obj2 = 0 ;
13227 char * kwnames[] = {
13228 (char *) "self",(char *) "pid",(char *) "status", NULL
13229 };
13230
13231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13233 if (!SWIG_IsOK(res1)) {
13234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13235 }
13236 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13237 ecode2 = SWIG_AsVal_int(obj1, &val2);
13238 if (!SWIG_IsOK(ecode2)) {
13239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13240 }
13241 arg2 = static_cast< int >(val2);
13242 ecode3 = SWIG_AsVal_int(obj2, &val3);
13243 if (!SWIG_IsOK(ecode3)) {
13244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13245 }
13246 arg3 = static_cast< int >(val3);
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 (arg1)->OnTerminate(arg2,arg3);
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_Py_Void();
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13261 PyObject *resultobj = 0;
13262 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13263 void *argp1 = 0 ;
13264 int res1 = 0 ;
13265 PyObject *swig_obj[1] ;
13266
13267 if (!args) SWIG_fail;
13268 swig_obj[0] = args;
13269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13270 if (!SWIG_IsOK(res1)) {
13271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13272 }
13273 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 (arg1)->Redirect();
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 resultobj = SWIG_Py_Void();
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13288 PyObject *resultobj = 0;
13289 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13290 bool result;
13291 void *argp1 = 0 ;
13292 int res1 = 0 ;
13293 PyObject *swig_obj[1] ;
13294
13295 if (!args) SWIG_fail;
13296 swig_obj[0] = args;
13297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13298 if (!SWIG_IsOK(res1)) {
13299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13300 }
13301 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 result = (bool)(arg1)->IsRedirected();
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 {
13309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13310 }
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13318 PyObject *resultobj = 0;
13319 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13320 void *argp1 = 0 ;
13321 int res1 = 0 ;
13322 PyObject *swig_obj[1] ;
13323
13324 if (!args) SWIG_fail;
13325 swig_obj[0] = args;
13326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13327 if (!SWIG_IsOK(res1)) {
13328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13329 }
13330 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 (arg1)->Detach();
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_Py_Void();
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13345 PyObject *resultobj = 0;
13346 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13347 wxInputStream *result = 0 ;
13348 void *argp1 = 0 ;
13349 int res1 = 0 ;
13350 PyObject *swig_obj[1] ;
13351
13352 if (!args) SWIG_fail;
13353 swig_obj[0] = args;
13354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13355 if (!SWIG_IsOK(res1)) {
13356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13357 }
13358 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (wxInputStream *)(arg1)->GetInputStream();
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 {
13366 wxPyInputStream * _ptr = NULL;
13367
13368 if (result) {
13369 _ptr = new wxPyInputStream(result);
13370 }
13371 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13372 }
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *resultobj = 0;
13381 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13382 wxInputStream *result = 0 ;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 PyObject *swig_obj[1] ;
13386
13387 if (!args) SWIG_fail;
13388 swig_obj[0] = args;
13389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13390 if (!SWIG_IsOK(res1)) {
13391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13392 }
13393 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 result = (wxInputStream *)(arg1)->GetErrorStream();
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 {
13401 wxPyInputStream * _ptr = NULL;
13402
13403 if (result) {
13404 _ptr = new wxPyInputStream(result);
13405 }
13406 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13407 }
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13415 PyObject *resultobj = 0;
13416 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13417 wxOutputStream *result = 0 ;
13418 void *argp1 = 0 ;
13419 int res1 = 0 ;
13420 PyObject *swig_obj[1] ;
13421
13422 if (!args) SWIG_fail;
13423 swig_obj[0] = args;
13424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13425 if (!SWIG_IsOK(res1)) {
13426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13427 }
13428 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (wxOutputStream *)(arg1)->GetOutputStream();
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13436 return resultobj;
13437 fail:
13438 return NULL;
13439 }
13440
13441
13442 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13443 PyObject *resultobj = 0;
13444 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13445 void *argp1 = 0 ;
13446 int res1 = 0 ;
13447 PyObject *swig_obj[1] ;
13448
13449 if (!args) SWIG_fail;
13450 swig_obj[0] = args;
13451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13452 if (!SWIG_IsOK(res1)) {
13453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13454 }
13455 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 (arg1)->CloseOutput();
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 resultobj = SWIG_Py_Void();
13463 return resultobj;
13464 fail:
13465 return NULL;
13466 }
13467
13468
13469 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13470 PyObject *resultobj = 0;
13471 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13472 bool result;
13473 void *argp1 = 0 ;
13474 int res1 = 0 ;
13475 PyObject *swig_obj[1] ;
13476
13477 if (!args) SWIG_fail;
13478 swig_obj[0] = args;
13479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13480 if (!SWIG_IsOK(res1)) {
13481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13482 }
13483 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13484 {
13485 PyThreadState* __tstate = wxPyBeginAllowThreads();
13486 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 {
13491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13492 }
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13500 PyObject *resultobj = 0;
13501 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13502 bool result;
13503 void *argp1 = 0 ;
13504 int res1 = 0 ;
13505 PyObject *swig_obj[1] ;
13506
13507 if (!args) SWIG_fail;
13508 swig_obj[0] = args;
13509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13510 if (!SWIG_IsOK(res1)) {
13511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13512 }
13513 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13522 }
13523 return resultobj;
13524 fail:
13525 return NULL;
13526 }
13527
13528
13529 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13530 PyObject *resultobj = 0;
13531 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13532 bool result;
13533 void *argp1 = 0 ;
13534 int res1 = 0 ;
13535 PyObject *swig_obj[1] ;
13536
13537 if (!args) SWIG_fail;
13538 swig_obj[0] = args;
13539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13540 if (!SWIG_IsOK(res1)) {
13541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13542 }
13543 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 {
13551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13552 }
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13560 PyObject *obj;
13561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13563 return SWIG_Py_Void();
13564 }
13565
13566 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13567 return SWIG_Python_InitShadowInstance(args);
13568 }
13569
13570 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj = 0;
13572 int arg1 = (int) 0 ;
13573 int arg2 = (int) 0 ;
13574 int arg3 = (int) 0 ;
13575 wxProcessEvent *result = 0 ;
13576 int val1 ;
13577 int ecode1 = 0 ;
13578 int val2 ;
13579 int ecode2 = 0 ;
13580 int val3 ;
13581 int ecode3 = 0 ;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 PyObject * obj2 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13590 if (obj0) {
13591 ecode1 = SWIG_AsVal_int(obj0, &val1);
13592 if (!SWIG_IsOK(ecode1)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13594 }
13595 arg1 = static_cast< int >(val1);
13596 }
13597 if (obj1) {
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 }
13604 if (obj2) {
13605 ecode3 = SWIG_AsVal_int(obj2, &val3);
13606 if (!SWIG_IsOK(ecode3)) {
13607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13608 }
13609 arg3 = static_cast< int >(val3);
13610 }
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13625 PyObject *resultobj = 0;
13626 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13627 int result;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 PyObject *swig_obj[1] ;
13631
13632 if (!args) SWIG_fail;
13633 swig_obj[0] = args;
13634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13635 if (!SWIG_IsOK(res1)) {
13636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13637 }
13638 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (int)(arg1)->GetPid();
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 resultobj = SWIG_From_int(static_cast< int >(result));
13646 return resultobj;
13647 fail:
13648 return NULL;
13649 }
13650
13651
13652 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13653 PyObject *resultobj = 0;
13654 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13655 int result;
13656 void *argp1 = 0 ;
13657 int res1 = 0 ;
13658 PyObject *swig_obj[1] ;
13659
13660 if (!args) SWIG_fail;
13661 swig_obj[0] = args;
13662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13663 if (!SWIG_IsOK(res1)) {
13664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13665 }
13666 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13667 {
13668 PyThreadState* __tstate = wxPyBeginAllowThreads();
13669 result = (int)(arg1)->GetExitCode();
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 resultobj = SWIG_From_int(static_cast< int >(result));
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13681 PyObject *resultobj = 0;
13682 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13683 int arg2 ;
13684 void *argp1 = 0 ;
13685 int res1 = 0 ;
13686 int val2 ;
13687 int ecode2 = 0 ;
13688 PyObject *swig_obj[2] ;
13689
13690 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13692 if (!SWIG_IsOK(res1)) {
13693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13694 }
13695 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13697 if (!SWIG_IsOK(ecode2)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13699 }
13700 arg2 = static_cast< int >(val2);
13701 if (arg1) (arg1)->m_pid = arg2;
13702
13703 resultobj = SWIG_Py_Void();
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13711 PyObject *resultobj = 0;
13712 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13713 int result;
13714 void *argp1 = 0 ;
13715 int res1 = 0 ;
13716 PyObject *swig_obj[1] ;
13717
13718 if (!args) SWIG_fail;
13719 swig_obj[0] = args;
13720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13721 if (!SWIG_IsOK(res1)) {
13722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13723 }
13724 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13725 result = (int) ((arg1)->m_pid);
13726 resultobj = SWIG_From_int(static_cast< int >(result));
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13734 PyObject *resultobj = 0;
13735 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13736 int arg2 ;
13737 void *argp1 = 0 ;
13738 int res1 = 0 ;
13739 int val2 ;
13740 int ecode2 = 0 ;
13741 PyObject *swig_obj[2] ;
13742
13743 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13745 if (!SWIG_IsOK(res1)) {
13746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13747 }
13748 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13749 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13750 if (!SWIG_IsOK(ecode2)) {
13751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13752 }
13753 arg2 = static_cast< int >(val2);
13754 if (arg1) (arg1)->m_exitcode = arg2;
13755
13756 resultobj = SWIG_Py_Void();
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13764 PyObject *resultobj = 0;
13765 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13766 int result;
13767 void *argp1 = 0 ;
13768 int res1 = 0 ;
13769 PyObject *swig_obj[1] ;
13770
13771 if (!args) SWIG_fail;
13772 swig_obj[0] = args;
13773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13774 if (!SWIG_IsOK(res1)) {
13775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13776 }
13777 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13778 result = (int) ((arg1)->m_exitcode);
13779 resultobj = SWIG_From_int(static_cast< int >(result));
13780 return resultobj;
13781 fail:
13782 return NULL;
13783 }
13784
13785
13786 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13787 PyObject *obj;
13788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13789 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13790 return SWIG_Py_Void();
13791 }
13792
13793 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13794 return SWIG_Python_InitShadowInstance(args);
13795 }
13796
13797 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxString *arg1 = 0 ;
13800 int arg2 = (int) wxEXEC_ASYNC ;
13801 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13802 long result;
13803 bool temp1 = false ;
13804 int val2 ;
13805 int ecode2 = 0 ;
13806 void *argp3 = 0 ;
13807 int res3 = 0 ;
13808 PyObject * obj0 = 0 ;
13809 PyObject * obj1 = 0 ;
13810 PyObject * obj2 = 0 ;
13811 char * kwnames[] = {
13812 (char *) "command",(char *) "flags",(char *) "process", NULL
13813 };
13814
13815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13816 {
13817 arg1 = wxString_in_helper(obj0);
13818 if (arg1 == NULL) SWIG_fail;
13819 temp1 = true;
13820 }
13821 if (obj1) {
13822 ecode2 = SWIG_AsVal_int(obj1, &val2);
13823 if (!SWIG_IsOK(ecode2)) {
13824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13825 }
13826 arg2 = static_cast< int >(val2);
13827 }
13828 if (obj2) {
13829 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13830 if (!SWIG_IsOK(res3)) {
13831 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13832 }
13833 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13834 }
13835 {
13836 if (!wxPyCheckForApp()) SWIG_fail;
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13839 wxPyEndAllowThreads(__tstate);
13840 if (PyErr_Occurred()) SWIG_fail;
13841 }
13842 resultobj = SWIG_From_long(static_cast< long >(result));
13843 {
13844 if (temp1)
13845 delete arg1;
13846 }
13847 return resultobj;
13848 fail:
13849 {
13850 if (temp1)
13851 delete arg1;
13852 }
13853 return NULL;
13854 }
13855
13856
13857 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj = 0;
13859 long arg1 ;
13860 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13861 wxKillError *arg3 = (wxKillError *) 0 ;
13862 int arg4 = (int) wxKILL_NOCHILDREN ;
13863 int result;
13864 long val1 ;
13865 int ecode1 = 0 ;
13866 int val2 ;
13867 int ecode2 = 0 ;
13868 wxKillError temp3 ;
13869 int val4 ;
13870 int ecode4 = 0 ;
13871 PyObject * obj0 = 0 ;
13872 PyObject * obj1 = 0 ;
13873 PyObject * obj2 = 0 ;
13874 char * kwnames[] = {
13875 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13876 };
13877
13878 {
13879 arg3 = &temp3;
13880 }
13881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13882 ecode1 = SWIG_AsVal_long(obj0, &val1);
13883 if (!SWIG_IsOK(ecode1)) {
13884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13885 }
13886 arg1 = static_cast< long >(val1);
13887 if (obj1) {
13888 ecode2 = SWIG_AsVal_int(obj1, &val2);
13889 if (!SWIG_IsOK(ecode2)) {
13890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13891 }
13892 arg2 = static_cast< wxSignal >(val2);
13893 }
13894 if (obj2) {
13895 ecode4 = SWIG_AsVal_int(obj2, &val4);
13896 if (!SWIG_IsOK(ecode4)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13898 }
13899 arg4 = static_cast< int >(val4);
13900 }
13901 {
13902 PyThreadState* __tstate = wxPyBeginAllowThreads();
13903 result = (int)wxKill(arg1,arg2,arg3,arg4);
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 resultobj = SWIG_From_int(static_cast< int >(result));
13908 {
13909 PyObject* o;
13910 o = PyInt_FromLong((long) (*arg3));
13911
13912
13913
13914 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13915
13916 }
13917 return resultobj;
13918 fail:
13919 return NULL;
13920 }
13921
13922
13923 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj = 0;
13925 int arg1 = (int) wxJOYSTICK1 ;
13926 wxJoystick *result = 0 ;
13927 int val1 ;
13928 int ecode1 = 0 ;
13929 PyObject * obj0 = 0 ;
13930 char * kwnames[] = {
13931 (char *) "joystick", NULL
13932 };
13933
13934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13935 if (obj0) {
13936 ecode1 = SWIG_AsVal_int(obj0, &val1);
13937 if (!SWIG_IsOK(ecode1)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13939 }
13940 arg1 = static_cast< int >(val1);
13941 }
13942 {
13943 if (!wxPyCheckForApp()) SWIG_fail;
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 result = (wxJoystick *)new wxJoystick(arg1);
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13950 return resultobj;
13951 fail:
13952 return NULL;
13953 }
13954
13955
13956 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13957 PyObject *resultobj = 0;
13958 wxJoystick *arg1 = (wxJoystick *) 0 ;
13959 void *argp1 = 0 ;
13960 int res1 = 0 ;
13961 PyObject *swig_obj[1] ;
13962
13963 if (!args) SWIG_fail;
13964 swig_obj[0] = args;
13965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13966 if (!SWIG_IsOK(res1)) {
13967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13968 }
13969 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13970 {
13971 PyThreadState* __tstate = wxPyBeginAllowThreads();
13972 delete arg1;
13973
13974 wxPyEndAllowThreads(__tstate);
13975 if (PyErr_Occurred()) SWIG_fail;
13976 }
13977 resultobj = SWIG_Py_Void();
13978 return resultobj;
13979 fail:
13980 return NULL;
13981 }
13982
13983
13984 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13985 PyObject *resultobj = 0;
13986 wxJoystick *arg1 = (wxJoystick *) 0 ;
13987 wxPoint result;
13988 void *argp1 = 0 ;
13989 int res1 = 0 ;
13990 PyObject *swig_obj[1] ;
13991
13992 if (!args) SWIG_fail;
13993 swig_obj[0] = args;
13994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13995 if (!SWIG_IsOK(res1)) {
13996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13997 }
13998 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13999 {
14000 PyThreadState* __tstate = wxPyBeginAllowThreads();
14001 result = (arg1)->GetPosition();
14002 wxPyEndAllowThreads(__tstate);
14003 if (PyErr_Occurred()) SWIG_fail;
14004 }
14005 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14006 return resultobj;
14007 fail:
14008 return NULL;
14009 }
14010
14011
14012 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14013 PyObject *resultobj = 0;
14014 wxJoystick *arg1 = (wxJoystick *) 0 ;
14015 int result;
14016 void *argp1 = 0 ;
14017 int res1 = 0 ;
14018 PyObject *swig_obj[1] ;
14019
14020 if (!args) SWIG_fail;
14021 swig_obj[0] = args;
14022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14023 if (!SWIG_IsOK(res1)) {
14024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14025 }
14026 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14027 {
14028 PyThreadState* __tstate = wxPyBeginAllowThreads();
14029 result = (int)(arg1)->GetZPosition();
14030 wxPyEndAllowThreads(__tstate);
14031 if (PyErr_Occurred()) SWIG_fail;
14032 }
14033 resultobj = SWIG_From_int(static_cast< int >(result));
14034 return resultobj;
14035 fail:
14036 return NULL;
14037 }
14038
14039
14040 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14041 PyObject *resultobj = 0;
14042 wxJoystick *arg1 = (wxJoystick *) 0 ;
14043 int result;
14044 void *argp1 = 0 ;
14045 int res1 = 0 ;
14046 PyObject *swig_obj[1] ;
14047
14048 if (!args) SWIG_fail;
14049 swig_obj[0] = args;
14050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14051 if (!SWIG_IsOK(res1)) {
14052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14053 }
14054 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (int)(arg1)->GetButtonState();
14058 wxPyEndAllowThreads(__tstate);
14059 if (PyErr_Occurred()) SWIG_fail;
14060 }
14061 resultobj = SWIG_From_int(static_cast< int >(result));
14062 return resultobj;
14063 fail:
14064 return NULL;
14065 }
14066
14067
14068 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14069 PyObject *resultobj = 0;
14070 wxJoystick *arg1 = (wxJoystick *) 0 ;
14071 int result;
14072 void *argp1 = 0 ;
14073 int res1 = 0 ;
14074 PyObject *swig_obj[1] ;
14075
14076 if (!args) SWIG_fail;
14077 swig_obj[0] = args;
14078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14079 if (!SWIG_IsOK(res1)) {
14080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14081 }
14082 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 result = (int)(arg1)->GetPOVPosition();
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 resultobj = SWIG_From_int(static_cast< int >(result));
14090 return resultobj;
14091 fail:
14092 return NULL;
14093 }
14094
14095
14096 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14097 PyObject *resultobj = 0;
14098 wxJoystick *arg1 = (wxJoystick *) 0 ;
14099 int result;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 PyObject *swig_obj[1] ;
14103
14104 if (!args) SWIG_fail;
14105 swig_obj[0] = args;
14106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14107 if (!SWIG_IsOK(res1)) {
14108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14109 }
14110 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 result = (int)(arg1)->GetPOVCTSPosition();
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 resultobj = SWIG_From_int(static_cast< int >(result));
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14125 PyObject *resultobj = 0;
14126 wxJoystick *arg1 = (wxJoystick *) 0 ;
14127 int result;
14128 void *argp1 = 0 ;
14129 int res1 = 0 ;
14130 PyObject *swig_obj[1] ;
14131
14132 if (!args) SWIG_fail;
14133 swig_obj[0] = args;
14134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14135 if (!SWIG_IsOK(res1)) {
14136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14137 }
14138 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14139 {
14140 PyThreadState* __tstate = wxPyBeginAllowThreads();
14141 result = (int)(arg1)->GetRudderPosition();
14142 wxPyEndAllowThreads(__tstate);
14143 if (PyErr_Occurred()) SWIG_fail;
14144 }
14145 resultobj = SWIG_From_int(static_cast< int >(result));
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14153 PyObject *resultobj = 0;
14154 wxJoystick *arg1 = (wxJoystick *) 0 ;
14155 int result;
14156 void *argp1 = 0 ;
14157 int res1 = 0 ;
14158 PyObject *swig_obj[1] ;
14159
14160 if (!args) SWIG_fail;
14161 swig_obj[0] = args;
14162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14163 if (!SWIG_IsOK(res1)) {
14164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14165 }
14166 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14167 {
14168 PyThreadState* __tstate = wxPyBeginAllowThreads();
14169 result = (int)(arg1)->GetUPosition();
14170 wxPyEndAllowThreads(__tstate);
14171 if (PyErr_Occurred()) SWIG_fail;
14172 }
14173 resultobj = SWIG_From_int(static_cast< int >(result));
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14181 PyObject *resultobj = 0;
14182 wxJoystick *arg1 = (wxJoystick *) 0 ;
14183 int result;
14184 void *argp1 = 0 ;
14185 int res1 = 0 ;
14186 PyObject *swig_obj[1] ;
14187
14188 if (!args) SWIG_fail;
14189 swig_obj[0] = args;
14190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14191 if (!SWIG_IsOK(res1)) {
14192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14193 }
14194 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 result = (int)(arg1)->GetVPosition();
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = SWIG_From_int(static_cast< int >(result));
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14209 PyObject *resultobj = 0;
14210 wxJoystick *arg1 = (wxJoystick *) 0 ;
14211 int result;
14212 void *argp1 = 0 ;
14213 int res1 = 0 ;
14214 PyObject *swig_obj[1] ;
14215
14216 if (!args) SWIG_fail;
14217 swig_obj[0] = args;
14218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14221 }
14222 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 result = (int)(arg1)->GetMovementThreshold();
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_From_int(static_cast< int >(result));
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj = 0;
14238 wxJoystick *arg1 = (wxJoystick *) 0 ;
14239 int arg2 ;
14240 void *argp1 = 0 ;
14241 int res1 = 0 ;
14242 int val2 ;
14243 int ecode2 = 0 ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 char * kwnames[] = {
14247 (char *) "self",(char *) "threshold", NULL
14248 };
14249
14250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14252 if (!SWIG_IsOK(res1)) {
14253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14254 }
14255 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14256 ecode2 = SWIG_AsVal_int(obj1, &val2);
14257 if (!SWIG_IsOK(ecode2)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14259 }
14260 arg2 = static_cast< int >(val2);
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 (arg1)->SetMovementThreshold(arg2);
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 resultobj = SWIG_Py_Void();
14268 return resultobj;
14269 fail:
14270 return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275 PyObject *resultobj = 0;
14276 wxJoystick *arg1 = (wxJoystick *) 0 ;
14277 bool result;
14278 void *argp1 = 0 ;
14279 int res1 = 0 ;
14280 PyObject *swig_obj[1] ;
14281
14282 if (!args) SWIG_fail;
14283 swig_obj[0] = args;
14284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14287 }
14288 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (bool)(arg1)->IsOk();
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 {
14296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14297 }
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14305 PyObject *resultobj = 0;
14306 wxJoystick *arg1 = (wxJoystick *) 0 ;
14307 int result;
14308 void *argp1 = 0 ;
14309 int res1 = 0 ;
14310 PyObject *swig_obj[1] ;
14311
14312 if (!args) SWIG_fail;
14313 swig_obj[0] = args;
14314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14315 if (!SWIG_IsOK(res1)) {
14316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14317 }
14318 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 result = (int)(arg1)->GetNumberJoysticks();
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = SWIG_From_int(static_cast< int >(result));
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14333 PyObject *resultobj = 0;
14334 wxJoystick *arg1 = (wxJoystick *) 0 ;
14335 int result;
14336 void *argp1 = 0 ;
14337 int res1 = 0 ;
14338 PyObject *swig_obj[1] ;
14339
14340 if (!args) SWIG_fail;
14341 swig_obj[0] = args;
14342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14343 if (!SWIG_IsOK(res1)) {
14344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14345 }
14346 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 result = (int)(arg1)->GetManufacturerId();
14350 wxPyEndAllowThreads(__tstate);
14351 if (PyErr_Occurred()) SWIG_fail;
14352 }
14353 resultobj = SWIG_From_int(static_cast< int >(result));
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14361 PyObject *resultobj = 0;
14362 wxJoystick *arg1 = (wxJoystick *) 0 ;
14363 int result;
14364 void *argp1 = 0 ;
14365 int res1 = 0 ;
14366 PyObject *swig_obj[1] ;
14367
14368 if (!args) SWIG_fail;
14369 swig_obj[0] = args;
14370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14371 if (!SWIG_IsOK(res1)) {
14372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14373 }
14374 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14375 {
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 result = (int)(arg1)->GetProductId();
14378 wxPyEndAllowThreads(__tstate);
14379 if (PyErr_Occurred()) SWIG_fail;
14380 }
14381 resultobj = SWIG_From_int(static_cast< int >(result));
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14389 PyObject *resultobj = 0;
14390 wxJoystick *arg1 = (wxJoystick *) 0 ;
14391 wxString result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 PyObject *swig_obj[1] ;
14395
14396 if (!args) SWIG_fail;
14397 swig_obj[0] = args;
14398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14401 }
14402 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 result = (arg1)->GetProductName();
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 {
14410 #if wxUSE_UNICODE
14411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14412 #else
14413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14414 #endif
14415 }
14416 return resultobj;
14417 fail:
14418 return NULL;
14419 }
14420
14421
14422 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14423 PyObject *resultobj = 0;
14424 wxJoystick *arg1 = (wxJoystick *) 0 ;
14425 int result;
14426 void *argp1 = 0 ;
14427 int res1 = 0 ;
14428 PyObject *swig_obj[1] ;
14429
14430 if (!args) SWIG_fail;
14431 swig_obj[0] = args;
14432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14435 }
14436 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 result = (int)(arg1)->GetXMin();
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = SWIG_From_int(static_cast< int >(result));
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14451 PyObject *resultobj = 0;
14452 wxJoystick *arg1 = (wxJoystick *) 0 ;
14453 int result;
14454 void *argp1 = 0 ;
14455 int res1 = 0 ;
14456 PyObject *swig_obj[1] ;
14457
14458 if (!args) SWIG_fail;
14459 swig_obj[0] = args;
14460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14461 if (!SWIG_IsOK(res1)) {
14462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14463 }
14464 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 result = (int)(arg1)->GetYMin();
14468 wxPyEndAllowThreads(__tstate);
14469 if (PyErr_Occurred()) SWIG_fail;
14470 }
14471 resultobj = SWIG_From_int(static_cast< int >(result));
14472 return resultobj;
14473 fail:
14474 return NULL;
14475 }
14476
14477
14478 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14479 PyObject *resultobj = 0;
14480 wxJoystick *arg1 = (wxJoystick *) 0 ;
14481 int result;
14482 void *argp1 = 0 ;
14483 int res1 = 0 ;
14484 PyObject *swig_obj[1] ;
14485
14486 if (!args) SWIG_fail;
14487 swig_obj[0] = args;
14488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14489 if (!SWIG_IsOK(res1)) {
14490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14491 }
14492 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 result = (int)(arg1)->GetZMin();
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 resultobj = SWIG_From_int(static_cast< int >(result));
14500 return resultobj;
14501 fail:
14502 return NULL;
14503 }
14504
14505
14506 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14507 PyObject *resultobj = 0;
14508 wxJoystick *arg1 = (wxJoystick *) 0 ;
14509 int result;
14510 void *argp1 = 0 ;
14511 int res1 = 0 ;
14512 PyObject *swig_obj[1] ;
14513
14514 if (!args) SWIG_fail;
14515 swig_obj[0] = args;
14516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14517 if (!SWIG_IsOK(res1)) {
14518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14519 }
14520 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (int)(arg1)->GetXMax();
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 resultobj = SWIG_From_int(static_cast< int >(result));
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14535 PyObject *resultobj = 0;
14536 wxJoystick *arg1 = (wxJoystick *) 0 ;
14537 int result;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 PyObject *swig_obj[1] ;
14541
14542 if (!args) SWIG_fail;
14543 swig_obj[0] = args;
14544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14545 if (!SWIG_IsOK(res1)) {
14546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14547 }
14548 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (int)(arg1)->GetYMax();
14552 wxPyEndAllowThreads(__tstate);
14553 if (PyErr_Occurred()) SWIG_fail;
14554 }
14555 resultobj = SWIG_From_int(static_cast< int >(result));
14556 return resultobj;
14557 fail:
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14563 PyObject *resultobj = 0;
14564 wxJoystick *arg1 = (wxJoystick *) 0 ;
14565 int result;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 PyObject *swig_obj[1] ;
14569
14570 if (!args) SWIG_fail;
14571 swig_obj[0] = args;
14572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14575 }
14576 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (int)(arg1)->GetZMax();
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 resultobj = SWIG_From_int(static_cast< int >(result));
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14591 PyObject *resultobj = 0;
14592 wxJoystick *arg1 = (wxJoystick *) 0 ;
14593 int result;
14594 void *argp1 = 0 ;
14595 int res1 = 0 ;
14596 PyObject *swig_obj[1] ;
14597
14598 if (!args) SWIG_fail;
14599 swig_obj[0] = args;
14600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14601 if (!SWIG_IsOK(res1)) {
14602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14603 }
14604 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (int)(arg1)->GetNumberButtons();
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 resultobj = SWIG_From_int(static_cast< int >(result));
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14619 PyObject *resultobj = 0;
14620 wxJoystick *arg1 = (wxJoystick *) 0 ;
14621 int result;
14622 void *argp1 = 0 ;
14623 int res1 = 0 ;
14624 PyObject *swig_obj[1] ;
14625
14626 if (!args) SWIG_fail;
14627 swig_obj[0] = args;
14628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14629 if (!SWIG_IsOK(res1)) {
14630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14631 }
14632 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14633 {
14634 PyThreadState* __tstate = wxPyBeginAllowThreads();
14635 result = (int)(arg1)->GetNumberAxes();
14636 wxPyEndAllowThreads(__tstate);
14637 if (PyErr_Occurred()) SWIG_fail;
14638 }
14639 resultobj = SWIG_From_int(static_cast< int >(result));
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14647 PyObject *resultobj = 0;
14648 wxJoystick *arg1 = (wxJoystick *) 0 ;
14649 int result;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 PyObject *swig_obj[1] ;
14653
14654 if (!args) SWIG_fail;
14655 swig_obj[0] = args;
14656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14657 if (!SWIG_IsOK(res1)) {
14658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14659 }
14660 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (int)(arg1)->GetMaxButtons();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_From_int(static_cast< int >(result));
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14675 PyObject *resultobj = 0;
14676 wxJoystick *arg1 = (wxJoystick *) 0 ;
14677 int result;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 PyObject *swig_obj[1] ;
14681
14682 if (!args) SWIG_fail;
14683 swig_obj[0] = args;
14684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14685 if (!SWIG_IsOK(res1)) {
14686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14687 }
14688 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (int)(arg1)->GetMaxAxes();
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 resultobj = SWIG_From_int(static_cast< int >(result));
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14703 PyObject *resultobj = 0;
14704 wxJoystick *arg1 = (wxJoystick *) 0 ;
14705 int result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 PyObject *swig_obj[1] ;
14709
14710 if (!args) SWIG_fail;
14711 swig_obj[0] = args;
14712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14713 if (!SWIG_IsOK(res1)) {
14714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14715 }
14716 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (int)(arg1)->GetPollingMin();
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 resultobj = SWIG_From_int(static_cast< int >(result));
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14731 PyObject *resultobj = 0;
14732 wxJoystick *arg1 = (wxJoystick *) 0 ;
14733 int result;
14734 void *argp1 = 0 ;
14735 int res1 = 0 ;
14736 PyObject *swig_obj[1] ;
14737
14738 if (!args) SWIG_fail;
14739 swig_obj[0] = args;
14740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14743 }
14744 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (int)(arg1)->GetPollingMax();
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 resultobj = SWIG_From_int(static_cast< int >(result));
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14759 PyObject *resultobj = 0;
14760 wxJoystick *arg1 = (wxJoystick *) 0 ;
14761 int result;
14762 void *argp1 = 0 ;
14763 int res1 = 0 ;
14764 PyObject *swig_obj[1] ;
14765
14766 if (!args) SWIG_fail;
14767 swig_obj[0] = args;
14768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14769 if (!SWIG_IsOK(res1)) {
14770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14771 }
14772 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (int)(arg1)->GetRudderMin();
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 resultobj = SWIG_From_int(static_cast< int >(result));
14780 return resultobj;
14781 fail:
14782 return NULL;
14783 }
14784
14785
14786 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14787 PyObject *resultobj = 0;
14788 wxJoystick *arg1 = (wxJoystick *) 0 ;
14789 int result;
14790 void *argp1 = 0 ;
14791 int res1 = 0 ;
14792 PyObject *swig_obj[1] ;
14793
14794 if (!args) SWIG_fail;
14795 swig_obj[0] = args;
14796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14797 if (!SWIG_IsOK(res1)) {
14798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14799 }
14800 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (int)(arg1)->GetRudderMax();
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 resultobj = SWIG_From_int(static_cast< int >(result));
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14815 PyObject *resultobj = 0;
14816 wxJoystick *arg1 = (wxJoystick *) 0 ;
14817 int result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 PyObject *swig_obj[1] ;
14821
14822 if (!args) SWIG_fail;
14823 swig_obj[0] = args;
14824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14825 if (!SWIG_IsOK(res1)) {
14826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14827 }
14828 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14829 {
14830 PyThreadState* __tstate = wxPyBeginAllowThreads();
14831 result = (int)(arg1)->GetUMin();
14832 wxPyEndAllowThreads(__tstate);
14833 if (PyErr_Occurred()) SWIG_fail;
14834 }
14835 resultobj = SWIG_From_int(static_cast< int >(result));
14836 return resultobj;
14837 fail:
14838 return NULL;
14839 }
14840
14841
14842 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14843 PyObject *resultobj = 0;
14844 wxJoystick *arg1 = (wxJoystick *) 0 ;
14845 int result;
14846 void *argp1 = 0 ;
14847 int res1 = 0 ;
14848 PyObject *swig_obj[1] ;
14849
14850 if (!args) SWIG_fail;
14851 swig_obj[0] = args;
14852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14853 if (!SWIG_IsOK(res1)) {
14854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14855 }
14856 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (int)(arg1)->GetUMax();
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_From_int(static_cast< int >(result));
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14871 PyObject *resultobj = 0;
14872 wxJoystick *arg1 = (wxJoystick *) 0 ;
14873 int result;
14874 void *argp1 = 0 ;
14875 int res1 = 0 ;
14876 PyObject *swig_obj[1] ;
14877
14878 if (!args) SWIG_fail;
14879 swig_obj[0] = args;
14880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14881 if (!SWIG_IsOK(res1)) {
14882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14883 }
14884 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14885 {
14886 PyThreadState* __tstate = wxPyBeginAllowThreads();
14887 result = (int)(arg1)->GetVMin();
14888 wxPyEndAllowThreads(__tstate);
14889 if (PyErr_Occurred()) SWIG_fail;
14890 }
14891 resultobj = SWIG_From_int(static_cast< int >(result));
14892 return resultobj;
14893 fail:
14894 return NULL;
14895 }
14896
14897
14898 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14899 PyObject *resultobj = 0;
14900 wxJoystick *arg1 = (wxJoystick *) 0 ;
14901 int result;
14902 void *argp1 = 0 ;
14903 int res1 = 0 ;
14904 PyObject *swig_obj[1] ;
14905
14906 if (!args) SWIG_fail;
14907 swig_obj[0] = args;
14908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14909 if (!SWIG_IsOK(res1)) {
14910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14911 }
14912 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (int)(arg1)->GetVMax();
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 resultobj = SWIG_From_int(static_cast< int >(result));
14920 return resultobj;
14921 fail:
14922 return NULL;
14923 }
14924
14925
14926 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14927 PyObject *resultobj = 0;
14928 wxJoystick *arg1 = (wxJoystick *) 0 ;
14929 bool result;
14930 void *argp1 = 0 ;
14931 int res1 = 0 ;
14932 PyObject *swig_obj[1] ;
14933
14934 if (!args) SWIG_fail;
14935 swig_obj[0] = args;
14936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14937 if (!SWIG_IsOK(res1)) {
14938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14939 }
14940 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14941 {
14942 PyThreadState* __tstate = wxPyBeginAllowThreads();
14943 result = (bool)(arg1)->HasRudder();
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14949 }
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14957 PyObject *resultobj = 0;
14958 wxJoystick *arg1 = (wxJoystick *) 0 ;
14959 bool result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 PyObject *swig_obj[1] ;
14963
14964 if (!args) SWIG_fail;
14965 swig_obj[0] = args;
14966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14967 if (!SWIG_IsOK(res1)) {
14968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14969 }
14970 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (bool)(arg1)->HasZ();
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 {
14978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14987 PyObject *resultobj = 0;
14988 wxJoystick *arg1 = (wxJoystick *) 0 ;
14989 bool result;
14990 void *argp1 = 0 ;
14991 int res1 = 0 ;
14992 PyObject *swig_obj[1] ;
14993
14994 if (!args) SWIG_fail;
14995 swig_obj[0] = args;
14996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14997 if (!SWIG_IsOK(res1)) {
14998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14999 }
15000 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (bool)(arg1)->HasU();
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 {
15008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15009 }
15010 return resultobj;
15011 fail:
15012 return NULL;
15013 }
15014
15015
15016 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15017 PyObject *resultobj = 0;
15018 wxJoystick *arg1 = (wxJoystick *) 0 ;
15019 bool result;
15020 void *argp1 = 0 ;
15021 int res1 = 0 ;
15022 PyObject *swig_obj[1] ;
15023
15024 if (!args) SWIG_fail;
15025 swig_obj[0] = args;
15026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15027 if (!SWIG_IsOK(res1)) {
15028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15029 }
15030 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15031 {
15032 PyThreadState* __tstate = wxPyBeginAllowThreads();
15033 result = (bool)(arg1)->HasV();
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 {
15038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15039 }
15040 return resultobj;
15041 fail:
15042 return NULL;
15043 }
15044
15045
15046 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15047 PyObject *resultobj = 0;
15048 wxJoystick *arg1 = (wxJoystick *) 0 ;
15049 bool result;
15050 void *argp1 = 0 ;
15051 int res1 = 0 ;
15052 PyObject *swig_obj[1] ;
15053
15054 if (!args) SWIG_fail;
15055 swig_obj[0] = args;
15056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15057 if (!SWIG_IsOK(res1)) {
15058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15059 }
15060 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (bool)(arg1)->HasPOV();
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 {
15068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15069 }
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxJoystick *arg1 = (wxJoystick *) 0 ;
15079 bool result;
15080 void *argp1 = 0 ;
15081 int res1 = 0 ;
15082 PyObject *swig_obj[1] ;
15083
15084 if (!args) SWIG_fail;
15085 swig_obj[0] = args;
15086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15087 if (!SWIG_IsOK(res1)) {
15088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15089 }
15090 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 result = (bool)(arg1)->HasPOV4Dir();
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 {
15098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15099 }
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15107 PyObject *resultobj = 0;
15108 wxJoystick *arg1 = (wxJoystick *) 0 ;
15109 bool result;
15110 void *argp1 = 0 ;
15111 int res1 = 0 ;
15112 PyObject *swig_obj[1] ;
15113
15114 if (!args) SWIG_fail;
15115 swig_obj[0] = args;
15116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15117 if (!SWIG_IsOK(res1)) {
15118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15119 }
15120 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15121 {
15122 PyThreadState* __tstate = wxPyBeginAllowThreads();
15123 result = (bool)(arg1)->HasPOVCTS();
15124 wxPyEndAllowThreads(__tstate);
15125 if (PyErr_Occurred()) SWIG_fail;
15126 }
15127 {
15128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15129 }
15130 return resultobj;
15131 fail:
15132 return NULL;
15133 }
15134
15135
15136 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15137 PyObject *resultobj = 0;
15138 wxJoystick *arg1 = (wxJoystick *) 0 ;
15139 wxWindow *arg2 = (wxWindow *) 0 ;
15140 int arg3 = (int) 0 ;
15141 bool result;
15142 void *argp1 = 0 ;
15143 int res1 = 0 ;
15144 void *argp2 = 0 ;
15145 int res2 = 0 ;
15146 int val3 ;
15147 int ecode3 = 0 ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 PyObject * obj2 = 0 ;
15151 char * kwnames[] = {
15152 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15153 };
15154
15155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15159 }
15160 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15162 if (!SWIG_IsOK(res2)) {
15163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15164 }
15165 arg2 = reinterpret_cast< wxWindow * >(argp2);
15166 if (obj2) {
15167 ecode3 = SWIG_AsVal_int(obj2, &val3);
15168 if (!SWIG_IsOK(ecode3)) {
15169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15170 }
15171 arg3 = static_cast< int >(val3);
15172 }
15173 {
15174 PyThreadState* __tstate = wxPyBeginAllowThreads();
15175 result = (bool)(arg1)->SetCapture(arg2,arg3);
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 {
15180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15181 }
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15189 PyObject *resultobj = 0;
15190 wxJoystick *arg1 = (wxJoystick *) 0 ;
15191 bool result;
15192 void *argp1 = 0 ;
15193 int res1 = 0 ;
15194 PyObject *swig_obj[1] ;
15195
15196 if (!args) SWIG_fail;
15197 swig_obj[0] = args;
15198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15201 }
15202 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 result = (bool)(arg1)->ReleaseCapture();
15206 wxPyEndAllowThreads(__tstate);
15207 if (PyErr_Occurred()) SWIG_fail;
15208 }
15209 {
15210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15211 }
15212 return resultobj;
15213 fail:
15214 return NULL;
15215 }
15216
15217
15218 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15219 PyObject *obj;
15220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15221 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15222 return SWIG_Py_Void();
15223 }
15224
15225 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 return SWIG_Python_InitShadowInstance(args);
15227 }
15228
15229 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj = 0;
15231 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15232 int arg2 = (int) 0 ;
15233 int arg3 = (int) wxJOYSTICK1 ;
15234 int arg4 = (int) 0 ;
15235 wxJoystickEvent *result = 0 ;
15236 int val1 ;
15237 int ecode1 = 0 ;
15238 int val2 ;
15239 int ecode2 = 0 ;
15240 int val3 ;
15241 int ecode3 = 0 ;
15242 int val4 ;
15243 int ecode4 = 0 ;
15244 PyObject * obj0 = 0 ;
15245 PyObject * obj1 = 0 ;
15246 PyObject * obj2 = 0 ;
15247 PyObject * obj3 = 0 ;
15248 char * kwnames[] = {
15249 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15250 };
15251
15252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15253 if (obj0) {
15254 ecode1 = SWIG_AsVal_int(obj0, &val1);
15255 if (!SWIG_IsOK(ecode1)) {
15256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15257 }
15258 arg1 = static_cast< wxEventType >(val1);
15259 }
15260 if (obj1) {
15261 ecode2 = SWIG_AsVal_int(obj1, &val2);
15262 if (!SWIG_IsOK(ecode2)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15264 }
15265 arg2 = static_cast< int >(val2);
15266 }
15267 if (obj2) {
15268 ecode3 = SWIG_AsVal_int(obj2, &val3);
15269 if (!SWIG_IsOK(ecode3)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15271 }
15272 arg3 = static_cast< int >(val3);
15273 }
15274 if (obj3) {
15275 ecode4 = SWIG_AsVal_int(obj3, &val4);
15276 if (!SWIG_IsOK(ecode4)) {
15277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15278 }
15279 arg4 = static_cast< int >(val4);
15280 }
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15288 return resultobj;
15289 fail:
15290 return NULL;
15291 }
15292
15293
15294 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15295 PyObject *resultobj = 0;
15296 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15297 wxPoint result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 PyObject *swig_obj[1] ;
15301
15302 if (!args) SWIG_fail;
15303 swig_obj[0] = args;
15304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15305 if (!SWIG_IsOK(res1)) {
15306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15307 }
15308 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15309 {
15310 PyThreadState* __tstate = wxPyBeginAllowThreads();
15311 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15323 PyObject *resultobj = 0;
15324 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15325 int result;
15326 void *argp1 = 0 ;
15327 int res1 = 0 ;
15328 PyObject *swig_obj[1] ;
15329
15330 if (!args) SWIG_fail;
15331 swig_obj[0] = args;
15332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15333 if (!SWIG_IsOK(res1)) {
15334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15335 }
15336 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15337 {
15338 PyThreadState* __tstate = wxPyBeginAllowThreads();
15339 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 resultobj = SWIG_From_int(static_cast< int >(result));
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351 PyObject *resultobj = 0;
15352 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15353 int result;
15354 void *argp1 = 0 ;
15355 int res1 = 0 ;
15356 PyObject *swig_obj[1] ;
15357
15358 if (!args) SWIG_fail;
15359 swig_obj[0] = args;
15360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15363 }
15364 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = SWIG_From_int(static_cast< int >(result));
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15379 PyObject *resultobj = 0;
15380 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15381 int result;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject *swig_obj[1] ;
15385
15386 if (!args) SWIG_fail;
15387 swig_obj[0] = args;
15388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15391 }
15392 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_From_int(static_cast< int >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15407 PyObject *resultobj = 0;
15408 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15409 int result;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 PyObject *swig_obj[1] ;
15413
15414 if (!args) SWIG_fail;
15415 swig_obj[0] = args;
15416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15417 if (!SWIG_IsOK(res1)) {
15418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15419 }
15420 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15421 {
15422 PyThreadState* __tstate = wxPyBeginAllowThreads();
15423 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 resultobj = SWIG_From_int(static_cast< int >(result));
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj = 0;
15436 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15437 int arg2 ;
15438 void *argp1 = 0 ;
15439 int res1 = 0 ;
15440 int val2 ;
15441 int ecode2 = 0 ;
15442 PyObject * obj0 = 0 ;
15443 PyObject * obj1 = 0 ;
15444 char * kwnames[] = {
15445 (char *) "self",(char *) "stick", NULL
15446 };
15447
15448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15452 }
15453 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15454 ecode2 = SWIG_AsVal_int(obj1, &val2);
15455 if (!SWIG_IsOK(ecode2)) {
15456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15457 }
15458 arg2 = static_cast< int >(val2);
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 (arg1)->SetJoystick(arg2);
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 resultobj = SWIG_Py_Void();
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj = 0;
15474 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15475 int arg2 ;
15476 void *argp1 = 0 ;
15477 int res1 = 0 ;
15478 int val2 ;
15479 int ecode2 = 0 ;
15480 PyObject * obj0 = 0 ;
15481 PyObject * obj1 = 0 ;
15482 char * kwnames[] = {
15483 (char *) "self",(char *) "state", NULL
15484 };
15485
15486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15490 }
15491 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15492 ecode2 = SWIG_AsVal_int(obj1, &val2);
15493 if (!SWIG_IsOK(ecode2)) {
15494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15495 }
15496 arg2 = static_cast< int >(val2);
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 (arg1)->SetButtonState(arg2);
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 resultobj = SWIG_Py_Void();
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15511 PyObject *resultobj = 0;
15512 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15513 int arg2 ;
15514 void *argp1 = 0 ;
15515 int res1 = 0 ;
15516 int val2 ;
15517 int ecode2 = 0 ;
15518 PyObject * obj0 = 0 ;
15519 PyObject * obj1 = 0 ;
15520 char * kwnames[] = {
15521 (char *) "self",(char *) "change", NULL
15522 };
15523
15524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15526 if (!SWIG_IsOK(res1)) {
15527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15528 }
15529 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15530 ecode2 = SWIG_AsVal_int(obj1, &val2);
15531 if (!SWIG_IsOK(ecode2)) {
15532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15533 }
15534 arg2 = static_cast< int >(val2);
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 (arg1)->SetButtonChange(arg2);
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 resultobj = SWIG_Py_Void();
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15549 PyObject *resultobj = 0;
15550 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15551 wxPoint *arg2 = 0 ;
15552 void *argp1 = 0 ;
15553 int res1 = 0 ;
15554 wxPoint temp2 ;
15555 PyObject * obj0 = 0 ;
15556 PyObject * obj1 = 0 ;
15557 char * kwnames[] = {
15558 (char *) "self",(char *) "pos", NULL
15559 };
15560
15561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15563 if (!SWIG_IsOK(res1)) {
15564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15565 }
15566 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15567 {
15568 arg2 = &temp2;
15569 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15570 }
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 (arg1)->SetPosition((wxPoint const &)*arg2);
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_Py_Void();
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15585 PyObject *resultobj = 0;
15586 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15587 int arg2 ;
15588 void *argp1 = 0 ;
15589 int res1 = 0 ;
15590 int val2 ;
15591 int ecode2 = 0 ;
15592 PyObject * obj0 = 0 ;
15593 PyObject * obj1 = 0 ;
15594 char * kwnames[] = {
15595 (char *) "self",(char *) "zPos", NULL
15596 };
15597
15598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15602 }
15603 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15604 ecode2 = SWIG_AsVal_int(obj1, &val2);
15605 if (!SWIG_IsOK(ecode2)) {
15606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15607 }
15608 arg2 = static_cast< int >(val2);
15609 {
15610 PyThreadState* __tstate = wxPyBeginAllowThreads();
15611 (arg1)->SetZPosition(arg2);
15612 wxPyEndAllowThreads(__tstate);
15613 if (PyErr_Occurred()) SWIG_fail;
15614 }
15615 resultobj = SWIG_Py_Void();
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15623 PyObject *resultobj = 0;
15624 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15625 bool result;
15626 void *argp1 = 0 ;
15627 int res1 = 0 ;
15628 PyObject *swig_obj[1] ;
15629
15630 if (!args) SWIG_fail;
15631 swig_obj[0] = args;
15632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15635 }
15636 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 {
15644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15645 }
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15653 PyObject *resultobj = 0;
15654 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15655 bool result;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 PyObject *swig_obj[1] ;
15659
15660 if (!args) SWIG_fail;
15661 swig_obj[0] = args;
15662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15663 if (!SWIG_IsOK(res1)) {
15664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15665 }
15666 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 {
15674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15675 }
15676 return resultobj;
15677 fail:
15678 return NULL;
15679 }
15680
15681
15682 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15683 PyObject *resultobj = 0;
15684 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15685 bool result;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 PyObject *swig_obj[1] ;
15689
15690 if (!args) SWIG_fail;
15691 swig_obj[0] = args;
15692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15693 if (!SWIG_IsOK(res1)) {
15694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15695 }
15696 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 {
15704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15705 }
15706 return resultobj;
15707 fail:
15708 return NULL;
15709 }
15710
15711
15712 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15713 PyObject *resultobj = 0;
15714 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15715 int arg2 = (int) wxJOY_BUTTON_ANY ;
15716 bool result;
15717 void *argp1 = 0 ;
15718 int res1 = 0 ;
15719 int val2 ;
15720 int ecode2 = 0 ;
15721 PyObject * obj0 = 0 ;
15722 PyObject * obj1 = 0 ;
15723 char * kwnames[] = {
15724 (char *) "self",(char *) "but", NULL
15725 };
15726
15727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15731 }
15732 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15733 if (obj1) {
15734 ecode2 = SWIG_AsVal_int(obj1, &val2);
15735 if (!SWIG_IsOK(ecode2)) {
15736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15737 }
15738 arg2 = static_cast< int >(val2);
15739 }
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 {
15747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15748 }
15749 return resultobj;
15750 fail:
15751 return NULL;
15752 }
15753
15754
15755 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15756 PyObject *resultobj = 0;
15757 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15758 int arg2 = (int) wxJOY_BUTTON_ANY ;
15759 bool result;
15760 void *argp1 = 0 ;
15761 int res1 = 0 ;
15762 int val2 ;
15763 int ecode2 = 0 ;
15764 PyObject * obj0 = 0 ;
15765 PyObject * obj1 = 0 ;
15766 char * kwnames[] = {
15767 (char *) "self",(char *) "but", NULL
15768 };
15769
15770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15772 if (!SWIG_IsOK(res1)) {
15773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15774 }
15775 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15776 if (obj1) {
15777 ecode2 = SWIG_AsVal_int(obj1, &val2);
15778 if (!SWIG_IsOK(ecode2)) {
15779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15780 }
15781 arg2 = static_cast< int >(val2);
15782 }
15783 {
15784 PyThreadState* __tstate = wxPyBeginAllowThreads();
15785 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 {
15790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15791 }
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15799 PyObject *resultobj = 0;
15800 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15801 int arg2 = (int) wxJOY_BUTTON_ANY ;
15802 bool result;
15803 void *argp1 = 0 ;
15804 int res1 = 0 ;
15805 int val2 ;
15806 int ecode2 = 0 ;
15807 PyObject * obj0 = 0 ;
15808 PyObject * obj1 = 0 ;
15809 char * kwnames[] = {
15810 (char *) "self",(char *) "but", NULL
15811 };
15812
15813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15815 if (!SWIG_IsOK(res1)) {
15816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15817 }
15818 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15819 if (obj1) {
15820 ecode2 = SWIG_AsVal_int(obj1, &val2);
15821 if (!SWIG_IsOK(ecode2)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15823 }
15824 arg2 = static_cast< int >(val2);
15825 }
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15842 PyObject *obj;
15843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15844 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15845 return SWIG_Py_Void();
15846 }
15847
15848 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15849 return SWIG_Python_InitShadowInstance(args);
15850 }
15851
15852 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15853 PyObject *resultobj = 0;
15854 wxString const &arg1_defvalue = wxPyEmptyString ;
15855 wxString *arg1 = (wxString *) &arg1_defvalue ;
15856 wxSound *result = 0 ;
15857 bool temp1 = false ;
15858 PyObject * obj0 = 0 ;
15859 char * kwnames[] = {
15860 (char *) "fileName", NULL
15861 };
15862
15863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15864 if (obj0) {
15865 {
15866 arg1 = wxString_in_helper(obj0);
15867 if (arg1 == NULL) SWIG_fail;
15868 temp1 = true;
15869 }
15870 }
15871 {
15872 if (!wxPyCheckForApp()) SWIG_fail;
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15879 {
15880 if (temp1)
15881 delete arg1;
15882 }
15883 return resultobj;
15884 fail:
15885 {
15886 if (temp1)
15887 delete arg1;
15888 }
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15894 PyObject *resultobj = 0;
15895 PyObject *arg1 = (PyObject *) 0 ;
15896 wxSound *result = 0 ;
15897 PyObject * obj0 = 0 ;
15898 char * kwnames[] = {
15899 (char *) "data", NULL
15900 };
15901
15902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15903 arg1 = obj0;
15904 {
15905 if (!wxPyCheckForApp()) SWIG_fail;
15906 PyThreadState* __tstate = wxPyBeginAllowThreads();
15907 result = (wxSound *)new_wxSound(arg1);
15908 wxPyEndAllowThreads(__tstate);
15909 if (PyErr_Occurred()) SWIG_fail;
15910 }
15911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15912 return resultobj;
15913 fail:
15914 return NULL;
15915 }
15916
15917
15918 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15919 PyObject *resultobj = 0;
15920 wxSound *arg1 = (wxSound *) 0 ;
15921 void *argp1 = 0 ;
15922 int res1 = 0 ;
15923 PyObject *swig_obj[1] ;
15924
15925 if (!args) SWIG_fail;
15926 swig_obj[0] = args;
15927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15930 }
15931 arg1 = reinterpret_cast< wxSound * >(argp1);
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 delete arg1;
15935
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 resultobj = SWIG_Py_Void();
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj = 0;
15948 wxSound *arg1 = (wxSound *) 0 ;
15949 wxString *arg2 = 0 ;
15950 bool result;
15951 void *argp1 = 0 ;
15952 int res1 = 0 ;
15953 bool temp2 = false ;
15954 PyObject * obj0 = 0 ;
15955 PyObject * obj1 = 0 ;
15956 char * kwnames[] = {
15957 (char *) "self",(char *) "fileName", NULL
15958 };
15959
15960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15962 if (!SWIG_IsOK(res1)) {
15963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15964 }
15965 arg1 = reinterpret_cast< wxSound * >(argp1);
15966 {
15967 arg2 = wxString_in_helper(obj1);
15968 if (arg2 == NULL) SWIG_fail;
15969 temp2 = true;
15970 }
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 result = (bool)(arg1)->Create((wxString const &)*arg2);
15974 wxPyEndAllowThreads(__tstate);
15975 if (PyErr_Occurred()) SWIG_fail;
15976 }
15977 {
15978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15979 }
15980 {
15981 if (temp2)
15982 delete arg2;
15983 }
15984 return resultobj;
15985 fail:
15986 {
15987 if (temp2)
15988 delete arg2;
15989 }
15990 return NULL;
15991 }
15992
15993
15994 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15995 PyObject *resultobj = 0;
15996 wxSound *arg1 = (wxSound *) 0 ;
15997 PyObject *arg2 = (PyObject *) 0 ;
15998 bool result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 PyObject * obj0 = 0 ;
16002 PyObject * obj1 = 0 ;
16003 char * kwnames[] = {
16004 (char *) "self",(char *) "data", NULL
16005 };
16006
16007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16011 }
16012 arg1 = reinterpret_cast< wxSound * >(argp1);
16013 arg2 = obj1;
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (bool)wxSound_CreateFromData(arg1,arg2);
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16030 PyObject *resultobj = 0;
16031 wxSound *arg1 = (wxSound *) 0 ;
16032 bool result;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 PyObject *swig_obj[1] ;
16036
16037 if (!args) SWIG_fail;
16038 swig_obj[0] = args;
16039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16040 if (!SWIG_IsOK(res1)) {
16041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16042 }
16043 arg1 = reinterpret_cast< wxSound * >(argp1);
16044 {
16045 PyThreadState* __tstate = wxPyBeginAllowThreads();
16046 result = (bool)(arg1)->IsOk();
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj = 0;
16061 wxSound *arg1 = (wxSound *) 0 ;
16062 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16063 bool result;
16064 void *argp1 = 0 ;
16065 int res1 = 0 ;
16066 unsigned int val2 ;
16067 int ecode2 = 0 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 char * kwnames[] = {
16071 (char *) "self",(char *) "flags", NULL
16072 };
16073
16074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16078 }
16079 arg1 = reinterpret_cast< wxSound * >(argp1);
16080 if (obj1) {
16081 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16084 }
16085 arg2 = static_cast< unsigned int >(val2);
16086 }
16087 {
16088 if (!wxPyCheckForApp()) SWIG_fail;
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (bool)((wxSound const *)arg1)->Play(arg2);
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 {
16095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16096 }
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxString *arg1 = 0 ;
16106 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16107 bool result;
16108 bool temp1 = false ;
16109 unsigned int val2 ;
16110 int ecode2 = 0 ;
16111 PyObject * obj0 = 0 ;
16112 PyObject * obj1 = 0 ;
16113 char * kwnames[] = {
16114 (char *) "filename",(char *) "flags", NULL
16115 };
16116
16117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16118 {
16119 arg1 = wxString_in_helper(obj0);
16120 if (arg1 == NULL) SWIG_fail;
16121 temp1 = true;
16122 }
16123 if (obj1) {
16124 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16125 if (!SWIG_IsOK(ecode2)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16127 }
16128 arg2 = static_cast< unsigned int >(val2);
16129 }
16130 {
16131 if (!wxPyCheckForApp()) SWIG_fail;
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16139 }
16140 {
16141 if (temp1)
16142 delete arg1;
16143 }
16144 return resultobj;
16145 fail:
16146 {
16147 if (temp1)
16148 delete arg1;
16149 }
16150 return NULL;
16151 }
16152
16153
16154 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16155 PyObject *resultobj = 0;
16156
16157 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16158 {
16159 if (!wxPyCheckForApp()) SWIG_fail;
16160 PyThreadState* __tstate = wxPyBeginAllowThreads();
16161 wxSound::Stop();
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 resultobj = SWIG_Py_Void();
16166 return resultobj;
16167 fail:
16168 return NULL;
16169 }
16170
16171
16172 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16173 PyObject *obj;
16174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16175 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16176 return SWIG_Py_Void();
16177 }
16178
16179 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16180 return SWIG_Python_InitShadowInstance(args);
16181 }
16182
16183 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj = 0;
16185 wxString *arg1 = 0 ;
16186 wxString *arg2 = 0 ;
16187 wxString *arg3 = 0 ;
16188 wxString *arg4 = 0 ;
16189 wxFileTypeInfo *result = 0 ;
16190 bool temp1 = false ;
16191 bool temp2 = false ;
16192 bool temp3 = false ;
16193 bool temp4 = false ;
16194 PyObject * obj0 = 0 ;
16195 PyObject * obj1 = 0 ;
16196 PyObject * obj2 = 0 ;
16197 PyObject * obj3 = 0 ;
16198 char * kwnames[] = {
16199 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16200 };
16201
16202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16203 {
16204 arg1 = wxString_in_helper(obj0);
16205 if (arg1 == NULL) SWIG_fail;
16206 temp1 = true;
16207 }
16208 {
16209 arg2 = wxString_in_helper(obj1);
16210 if (arg2 == NULL) SWIG_fail;
16211 temp2 = true;
16212 }
16213 {
16214 arg3 = wxString_in_helper(obj2);
16215 if (arg3 == NULL) SWIG_fail;
16216 temp3 = true;
16217 }
16218 {
16219 arg4 = wxString_in_helper(obj3);
16220 if (arg4 == NULL) SWIG_fail;
16221 temp4 = true;
16222 }
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16230 {
16231 if (temp1)
16232 delete arg1;
16233 }
16234 {
16235 if (temp2)
16236 delete arg2;
16237 }
16238 {
16239 if (temp3)
16240 delete arg3;
16241 }
16242 {
16243 if (temp4)
16244 delete arg4;
16245 }
16246 return resultobj;
16247 fail:
16248 {
16249 if (temp1)
16250 delete arg1;
16251 }
16252 {
16253 if (temp2)
16254 delete arg2;
16255 }
16256 {
16257 if (temp3)
16258 delete arg3;
16259 }
16260 {
16261 if (temp4)
16262 delete arg4;
16263 }
16264 return NULL;
16265 }
16266
16267
16268 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj = 0;
16270 wxArrayString *arg1 = 0 ;
16271 wxFileTypeInfo *result = 0 ;
16272 bool temp1 = false ;
16273 PyObject * obj0 = 0 ;
16274 char * kwnames[] = {
16275 (char *) "sArray", NULL
16276 };
16277
16278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16279 {
16280 if (! PySequence_Check(obj0)) {
16281 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16282 SWIG_fail;
16283 }
16284 arg1 = new wxArrayString;
16285 temp1 = true;
16286 int i, len=PySequence_Length(obj0);
16287 for (i=0; i<len; i++) {
16288 PyObject* item = PySequence_GetItem(obj0, i);
16289 wxString* s = wxString_in_helper(item);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 arg1->Add(*s);
16292 delete s;
16293 Py_DECREF(item);
16294 }
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16303 {
16304 if (temp1) delete arg1;
16305 }
16306 return resultobj;
16307 fail:
16308 {
16309 if (temp1) delete arg1;
16310 }
16311 return NULL;
16312 }
16313
16314
16315 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16316 PyObject *resultobj = 0;
16317 wxFileTypeInfo *result = 0 ;
16318
16319 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16320 {
16321 PyThreadState* __tstate = wxPyBeginAllowThreads();
16322 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16323 wxPyEndAllowThreads(__tstate);
16324 if (PyErr_Occurred()) SWIG_fail;
16325 }
16326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16327 return resultobj;
16328 fail:
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16334 PyObject *resultobj = 0;
16335 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16336 bool result;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 PyObject *swig_obj[1] ;
16340
16341 if (!args) SWIG_fail;
16342 swig_obj[0] = args;
16343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16344 if (!SWIG_IsOK(res1)) {
16345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16346 }
16347 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16356 }
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj = 0;
16365 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16366 wxString *arg2 = 0 ;
16367 int arg3 = (int) 0 ;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 bool temp2 = false ;
16371 int val3 ;
16372 int ecode3 = 0 ;
16373 PyObject * obj0 = 0 ;
16374 PyObject * obj1 = 0 ;
16375 PyObject * obj2 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16384 }
16385 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16386 {
16387 arg2 = wxString_in_helper(obj1);
16388 if (arg2 == NULL) SWIG_fail;
16389 temp2 = true;
16390 }
16391 if (obj2) {
16392 ecode3 = SWIG_AsVal_int(obj2, &val3);
16393 if (!SWIG_IsOK(ecode3)) {
16394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16395 }
16396 arg3 = static_cast< int >(val3);
16397 }
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 resultobj = SWIG_Py_Void();
16405 {
16406 if (temp2)
16407 delete arg2;
16408 }
16409 return resultobj;
16410 fail:
16411 {
16412 if (temp2)
16413 delete arg2;
16414 }
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16422 wxString *arg2 = 0 ;
16423 void *argp1 = 0 ;
16424 int res1 = 0 ;
16425 bool temp2 = false ;
16426 PyObject * obj0 = 0 ;
16427 PyObject * obj1 = 0 ;
16428 char * kwnames[] = {
16429 (char *) "self",(char *) "shortDesc", NULL
16430 };
16431
16432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16434 if (!SWIG_IsOK(res1)) {
16435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16436 }
16437 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16438 {
16439 arg2 = wxString_in_helper(obj1);
16440 if (arg2 == NULL) SWIG_fail;
16441 temp2 = true;
16442 }
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 (arg1)->SetShortDesc((wxString const &)*arg2);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_Py_Void();
16450 {
16451 if (temp2)
16452 delete arg2;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 return NULL;
16461 }
16462
16463
16464 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16465 PyObject *resultobj = 0;
16466 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16467 wxString *result = 0 ;
16468 void *argp1 = 0 ;
16469 int res1 = 0 ;
16470 PyObject *swig_obj[1] ;
16471
16472 if (!args) SWIG_fail;
16473 swig_obj[0] = args;
16474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16475 if (!SWIG_IsOK(res1)) {
16476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16477 }
16478 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16479 {
16480 PyThreadState* __tstate = wxPyBeginAllowThreads();
16481 {
16482 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16483 result = (wxString *) &_result_ref;
16484 }
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 {
16489 #if wxUSE_UNICODE
16490 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16491 #else
16492 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16493 #endif
16494 }
16495 return resultobj;
16496 fail:
16497 return NULL;
16498 }
16499
16500
16501 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16502 PyObject *resultobj = 0;
16503 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16504 wxString *result = 0 ;
16505 void *argp1 = 0 ;
16506 int res1 = 0 ;
16507 PyObject *swig_obj[1] ;
16508
16509 if (!args) SWIG_fail;
16510 swig_obj[0] = args;
16511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16512 if (!SWIG_IsOK(res1)) {
16513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16514 }
16515 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16516 {
16517 PyThreadState* __tstate = wxPyBeginAllowThreads();
16518 {
16519 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16520 result = (wxString *) &_result_ref;
16521 }
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 {
16526 #if wxUSE_UNICODE
16527 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16528 #else
16529 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16530 #endif
16531 }
16532 return resultobj;
16533 fail:
16534 return NULL;
16535 }
16536
16537
16538 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16539 PyObject *resultobj = 0;
16540 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16541 wxString *result = 0 ;
16542 void *argp1 = 0 ;
16543 int res1 = 0 ;
16544 PyObject *swig_obj[1] ;
16545
16546 if (!args) SWIG_fail;
16547 swig_obj[0] = args;
16548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16551 }
16552 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 {
16556 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16557 result = (wxString *) &_result_ref;
16558 }
16559 wxPyEndAllowThreads(__tstate);
16560 if (PyErr_Occurred()) SWIG_fail;
16561 }
16562 {
16563 #if wxUSE_UNICODE
16564 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16565 #else
16566 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16567 #endif
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16576 PyObject *resultobj = 0;
16577 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16578 wxString *result = 0 ;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 PyObject *swig_obj[1] ;
16582
16583 if (!args) SWIG_fail;
16584 swig_obj[0] = args;
16585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16586 if (!SWIG_IsOK(res1)) {
16587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16588 }
16589 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 {
16593 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16594 result = (wxString *) &_result_ref;
16595 }
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 {
16600 #if wxUSE_UNICODE
16601 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16602 #else
16603 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16604 #endif
16605 }
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16613 PyObject *resultobj = 0;
16614 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16615 wxString *result = 0 ;
16616 void *argp1 = 0 ;
16617 int res1 = 0 ;
16618 PyObject *swig_obj[1] ;
16619
16620 if (!args) SWIG_fail;
16621 swig_obj[0] = args;
16622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16623 if (!SWIG_IsOK(res1)) {
16624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16625 }
16626 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 {
16630 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16631 result = (wxString *) &_result_ref;
16632 }
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 #if wxUSE_UNICODE
16638 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16639 #else
16640 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16641 #endif
16642 }
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16650 PyObject *resultobj = 0;
16651 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16652 wxArrayString *result = 0 ;
16653 void *argp1 = 0 ;
16654 int res1 = 0 ;
16655 PyObject *swig_obj[1] ;
16656
16657 if (!args) SWIG_fail;
16658 swig_obj[0] = args;
16659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16660 if (!SWIG_IsOK(res1)) {
16661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16662 }
16663 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16664 {
16665 PyThreadState* __tstate = wxPyBeginAllowThreads();
16666 {
16667 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16668 result = (wxArrayString *) &_result_ref;
16669 }
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 {
16674 resultobj = wxArrayString2PyList_helper(*result);
16675 }
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16683 PyObject *resultobj = 0;
16684 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16685 size_t result;
16686 void *argp1 = 0 ;
16687 int res1 = 0 ;
16688 PyObject *swig_obj[1] ;
16689
16690 if (!args) SWIG_fail;
16691 swig_obj[0] = args;
16692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16693 if (!SWIG_IsOK(res1)) {
16694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16695 }
16696 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16711 PyObject *resultobj = 0;
16712 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16713 wxString *result = 0 ;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 PyObject *swig_obj[1] ;
16717
16718 if (!args) SWIG_fail;
16719 swig_obj[0] = args;
16720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16723 }
16724 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16725 {
16726 PyThreadState* __tstate = wxPyBeginAllowThreads();
16727 {
16728 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16729 result = (wxString *) &_result_ref;
16730 }
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 {
16735 #if wxUSE_UNICODE
16736 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16737 #else
16738 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16739 #endif
16740 }
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16748 PyObject *resultobj = 0;
16749 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16750 int result;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 PyObject *swig_obj[1] ;
16754
16755 if (!args) SWIG_fail;
16756 swig_obj[0] = args;
16757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16760 }
16761 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 resultobj = SWIG_From_int(static_cast< int >(result));
16769 return resultobj;
16770 fail:
16771 return NULL;
16772 }
16773
16774
16775 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16776 PyObject *obj;
16777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16778 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16779 return SWIG_Py_Void();
16780 }
16781
16782 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16783 return SWIG_Python_InitShadowInstance(args);
16784 }
16785
16786 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj = 0;
16788 wxFileTypeInfo *arg1 = 0 ;
16789 wxFileType *result = 0 ;
16790 void *argp1 = 0 ;
16791 int res1 = 0 ;
16792 PyObject * obj0 = 0 ;
16793 char * kwnames[] = {
16794 (char *) "ftInfo", NULL
16795 };
16796
16797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16798 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16799 if (!SWIG_IsOK(res1)) {
16800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16801 }
16802 if (!argp1) {
16803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16804 }
16805 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16820 PyObject *resultobj = 0;
16821 wxFileType *arg1 = (wxFileType *) 0 ;
16822 void *argp1 = 0 ;
16823 int res1 = 0 ;
16824 PyObject *swig_obj[1] ;
16825
16826 if (!args) SWIG_fail;
16827 swig_obj[0] = args;
16828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16829 if (!SWIG_IsOK(res1)) {
16830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16831 }
16832 arg1 = reinterpret_cast< wxFileType * >(argp1);
16833 {
16834 PyThreadState* __tstate = wxPyBeginAllowThreads();
16835 delete arg1;
16836
16837 wxPyEndAllowThreads(__tstate);
16838 if (PyErr_Occurred()) SWIG_fail;
16839 }
16840 resultobj = SWIG_Py_Void();
16841 return resultobj;
16842 fail:
16843 return NULL;
16844 }
16845
16846
16847 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16848 PyObject *resultobj = 0;
16849 wxFileType *arg1 = (wxFileType *) 0 ;
16850 PyObject *result = 0 ;
16851 void *argp1 = 0 ;
16852 int res1 = 0 ;
16853 PyObject *swig_obj[1] ;
16854
16855 if (!args) SWIG_fail;
16856 swig_obj[0] = args;
16857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16858 if (!SWIG_IsOK(res1)) {
16859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16860 }
16861 arg1 = reinterpret_cast< wxFileType * >(argp1);
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = (PyObject *)wxFileType_GetMimeType(arg1);
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 resultobj = result;
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16876 PyObject *resultobj = 0;
16877 wxFileType *arg1 = (wxFileType *) 0 ;
16878 PyObject *result = 0 ;
16879 void *argp1 = 0 ;
16880 int res1 = 0 ;
16881 PyObject *swig_obj[1] ;
16882
16883 if (!args) SWIG_fail;
16884 swig_obj[0] = args;
16885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16886 if (!SWIG_IsOK(res1)) {
16887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16888 }
16889 arg1 = reinterpret_cast< wxFileType * >(argp1);
16890 {
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 resultobj = result;
16897 return resultobj;
16898 fail:
16899 return NULL;
16900 }
16901
16902
16903 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16904 PyObject *resultobj = 0;
16905 wxFileType *arg1 = (wxFileType *) 0 ;
16906 PyObject *result = 0 ;
16907 void *argp1 = 0 ;
16908 int res1 = 0 ;
16909 PyObject *swig_obj[1] ;
16910
16911 if (!args) SWIG_fail;
16912 swig_obj[0] = args;
16913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16914 if (!SWIG_IsOK(res1)) {
16915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16916 }
16917 arg1 = reinterpret_cast< wxFileType * >(argp1);
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = (PyObject *)wxFileType_GetExtensions(arg1);
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 resultobj = result;
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16932 PyObject *resultobj = 0;
16933 wxFileType *arg1 = (wxFileType *) 0 ;
16934 wxIcon *result = 0 ;
16935 void *argp1 = 0 ;
16936 int res1 = 0 ;
16937 PyObject *swig_obj[1] ;
16938
16939 if (!args) SWIG_fail;
16940 swig_obj[0] = args;
16941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16942 if (!SWIG_IsOK(res1)) {
16943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16944 }
16945 arg1 = reinterpret_cast< wxFileType * >(argp1);
16946 {
16947 PyThreadState* __tstate = wxPyBeginAllowThreads();
16948 result = (wxIcon *)wxFileType_GetIcon(arg1);
16949 wxPyEndAllowThreads(__tstate);
16950 if (PyErr_Occurred()) SWIG_fail;
16951 }
16952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 PyObject *resultobj = 0;
16961 wxFileType *arg1 = (wxFileType *) 0 ;
16962 PyObject *result = 0 ;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 PyObject *swig_obj[1] ;
16966
16967 if (!args) SWIG_fail;
16968 swig_obj[0] = args;
16969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16972 }
16973 arg1 = reinterpret_cast< wxFileType * >(argp1);
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 resultobj = result;
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16988 PyObject *resultobj = 0;
16989 wxFileType *arg1 = (wxFileType *) 0 ;
16990 PyObject *result = 0 ;
16991 void *argp1 = 0 ;
16992 int res1 = 0 ;
16993 PyObject *swig_obj[1] ;
16994
16995 if (!args) SWIG_fail;
16996 swig_obj[0] = args;
16997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16998 if (!SWIG_IsOK(res1)) {
16999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17000 }
17001 arg1 = reinterpret_cast< wxFileType * >(argp1);
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (PyObject *)wxFileType_GetDescription(arg1);
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 resultobj = result;
17009 return resultobj;
17010 fail:
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxFileType *arg1 = (wxFileType *) 0 ;
17018 wxString *arg2 = 0 ;
17019 wxString const &arg3_defvalue = wxPyEmptyString ;
17020 wxString *arg3 = (wxString *) &arg3_defvalue ;
17021 PyObject *result = 0 ;
17022 void *argp1 = 0 ;
17023 int res1 = 0 ;
17024 bool temp2 = false ;
17025 bool temp3 = false ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 PyObject * obj2 = 0 ;
17029 char * kwnames[] = {
17030 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17031 };
17032
17033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17035 if (!SWIG_IsOK(res1)) {
17036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17037 }
17038 arg1 = reinterpret_cast< wxFileType * >(argp1);
17039 {
17040 arg2 = wxString_in_helper(obj1);
17041 if (arg2 == NULL) SWIG_fail;
17042 temp2 = true;
17043 }
17044 if (obj2) {
17045 {
17046 arg3 = wxString_in_helper(obj2);
17047 if (arg3 == NULL) SWIG_fail;
17048 temp3 = true;
17049 }
17050 }
17051 {
17052 PyThreadState* __tstate = wxPyBeginAllowThreads();
17053 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 resultobj = result;
17058 {
17059 if (temp2)
17060 delete arg2;
17061 }
17062 {
17063 if (temp3)
17064 delete arg3;
17065 }
17066 return resultobj;
17067 fail:
17068 {
17069 if (temp2)
17070 delete arg2;
17071 }
17072 {
17073 if (temp3)
17074 delete arg3;
17075 }
17076 return NULL;
17077 }
17078
17079
17080 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj = 0;
17082 wxFileType *arg1 = (wxFileType *) 0 ;
17083 wxString *arg2 = 0 ;
17084 wxString const &arg3_defvalue = wxPyEmptyString ;
17085 wxString *arg3 = (wxString *) &arg3_defvalue ;
17086 PyObject *result = 0 ;
17087 void *argp1 = 0 ;
17088 int res1 = 0 ;
17089 bool temp2 = false ;
17090 bool temp3 = false ;
17091 PyObject * obj0 = 0 ;
17092 PyObject * obj1 = 0 ;
17093 PyObject * obj2 = 0 ;
17094 char * kwnames[] = {
17095 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17096 };
17097
17098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17100 if (!SWIG_IsOK(res1)) {
17101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17102 }
17103 arg1 = reinterpret_cast< wxFileType * >(argp1);
17104 {
17105 arg2 = wxString_in_helper(obj1);
17106 if (arg2 == NULL) SWIG_fail;
17107 temp2 = true;
17108 }
17109 if (obj2) {
17110 {
17111 arg3 = wxString_in_helper(obj2);
17112 if (arg3 == NULL) SWIG_fail;
17113 temp3 = true;
17114 }
17115 }
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 resultobj = result;
17123 {
17124 if (temp2)
17125 delete arg2;
17126 }
17127 {
17128 if (temp3)
17129 delete arg3;
17130 }
17131 return resultobj;
17132 fail:
17133 {
17134 if (temp2)
17135 delete arg2;
17136 }
17137 {
17138 if (temp3)
17139 delete arg3;
17140 }
17141 return NULL;
17142 }
17143
17144
17145 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17146 PyObject *resultobj = 0;
17147 wxFileType *arg1 = (wxFileType *) 0 ;
17148 wxString *arg2 = 0 ;
17149 wxString const &arg3_defvalue = wxPyEmptyString ;
17150 wxString *arg3 = (wxString *) &arg3_defvalue ;
17151 PyObject *result = 0 ;
17152 void *argp1 = 0 ;
17153 int res1 = 0 ;
17154 bool temp2 = false ;
17155 bool temp3 = false ;
17156 PyObject * obj0 = 0 ;
17157 PyObject * obj1 = 0 ;
17158 PyObject * obj2 = 0 ;
17159 char * kwnames[] = {
17160 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17161 };
17162
17163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17165 if (!SWIG_IsOK(res1)) {
17166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17167 }
17168 arg1 = reinterpret_cast< wxFileType * >(argp1);
17169 {
17170 arg2 = wxString_in_helper(obj1);
17171 if (arg2 == NULL) SWIG_fail;
17172 temp2 = true;
17173 }
17174 if (obj2) {
17175 {
17176 arg3 = wxString_in_helper(obj2);
17177 if (arg3 == NULL) SWIG_fail;
17178 temp3 = true;
17179 }
17180 }
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = result;
17188 {
17189 if (temp2)
17190 delete arg2;
17191 }
17192 {
17193 if (temp3)
17194 delete arg3;
17195 }
17196 return resultobj;
17197 fail:
17198 {
17199 if (temp2)
17200 delete arg2;
17201 }
17202 {
17203 if (temp3)
17204 delete arg3;
17205 }
17206 return NULL;
17207 }
17208
17209
17210 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj = 0;
17212 wxFileType *arg1 = (wxFileType *) 0 ;
17213 wxString *arg2 = 0 ;
17214 wxString *arg3 = 0 ;
17215 bool arg4 = (bool) true ;
17216 bool result;
17217 void *argp1 = 0 ;
17218 int res1 = 0 ;
17219 bool temp2 = false ;
17220 bool temp3 = false ;
17221 bool val4 ;
17222 int ecode4 = 0 ;
17223 PyObject * obj0 = 0 ;
17224 PyObject * obj1 = 0 ;
17225 PyObject * obj2 = 0 ;
17226 PyObject * obj3 = 0 ;
17227 char * kwnames[] = {
17228 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17229 };
17230
17231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17233 if (!SWIG_IsOK(res1)) {
17234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17235 }
17236 arg1 = reinterpret_cast< wxFileType * >(argp1);
17237 {
17238 arg2 = wxString_in_helper(obj1);
17239 if (arg2 == NULL) SWIG_fail;
17240 temp2 = true;
17241 }
17242 {
17243 arg3 = wxString_in_helper(obj2);
17244 if (arg3 == NULL) SWIG_fail;
17245 temp3 = true;
17246 }
17247 if (obj3) {
17248 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17249 if (!SWIG_IsOK(ecode4)) {
17250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17251 }
17252 arg4 = static_cast< bool >(val4);
17253 }
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 {
17261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17262 }
17263 {
17264 if (temp2)
17265 delete arg2;
17266 }
17267 {
17268 if (temp3)
17269 delete arg3;
17270 }
17271 return resultobj;
17272 fail:
17273 {
17274 if (temp2)
17275 delete arg2;
17276 }
17277 {
17278 if (temp3)
17279 delete arg3;
17280 }
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxFileType *arg1 = (wxFileType *) 0 ;
17288 wxString const &arg2_defvalue = wxPyEmptyString ;
17289 wxString *arg2 = (wxString *) &arg2_defvalue ;
17290 int arg3 = (int) 0 ;
17291 bool result;
17292 void *argp1 = 0 ;
17293 int res1 = 0 ;
17294 bool temp2 = false ;
17295 int val3 ;
17296 int ecode3 = 0 ;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 PyObject * obj2 = 0 ;
17300 char * kwnames[] = {
17301 (char *) "self",(char *) "cmd",(char *) "index", NULL
17302 };
17303
17304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17306 if (!SWIG_IsOK(res1)) {
17307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17308 }
17309 arg1 = reinterpret_cast< wxFileType * >(argp1);
17310 if (obj1) {
17311 {
17312 arg2 = wxString_in_helper(obj1);
17313 if (arg2 == NULL) SWIG_fail;
17314 temp2 = true;
17315 }
17316 }
17317 if (obj2) {
17318 ecode3 = SWIG_AsVal_int(obj2, &val3);
17319 if (!SWIG_IsOK(ecode3)) {
17320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17321 }
17322 arg3 = static_cast< int >(val3);
17323 }
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 {
17331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17332 }
17333 {
17334 if (temp2)
17335 delete arg2;
17336 }
17337 return resultobj;
17338 fail:
17339 {
17340 if (temp2)
17341 delete arg2;
17342 }
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *resultobj = 0;
17349 wxFileType *arg1 = (wxFileType *) 0 ;
17350 bool result;
17351 void *argp1 = 0 ;
17352 int res1 = 0 ;
17353 PyObject *swig_obj[1] ;
17354
17355 if (!args) SWIG_fail;
17356 swig_obj[0] = args;
17357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17358 if (!SWIG_IsOK(res1)) {
17359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17360 }
17361 arg1 = reinterpret_cast< wxFileType * >(argp1);
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (bool)(arg1)->Unassociate();
17365 wxPyEndAllowThreads(__tstate);
17366 if (PyErr_Occurred()) SWIG_fail;
17367 }
17368 {
17369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj = 0;
17379 wxString *arg1 = 0 ;
17380 wxString *arg2 = 0 ;
17381 wxString const &arg3_defvalue = wxPyEmptyString ;
17382 wxString *arg3 = (wxString *) &arg3_defvalue ;
17383 wxString result;
17384 bool temp1 = false ;
17385 bool temp2 = false ;
17386 bool temp3 = false ;
17387 PyObject * obj0 = 0 ;
17388 PyObject * obj1 = 0 ;
17389 PyObject * obj2 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17395 {
17396 arg1 = wxString_in_helper(obj0);
17397 if (arg1 == NULL) SWIG_fail;
17398 temp1 = true;
17399 }
17400 {
17401 arg2 = wxString_in_helper(obj1);
17402 if (arg2 == NULL) SWIG_fail;
17403 temp2 = true;
17404 }
17405 if (obj2) {
17406 {
17407 arg3 = wxString_in_helper(obj2);
17408 if (arg3 == NULL) SWIG_fail;
17409 temp3 = true;
17410 }
17411 }
17412 {
17413 PyThreadState* __tstate = wxPyBeginAllowThreads();
17414 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17415 wxPyEndAllowThreads(__tstate);
17416 if (PyErr_Occurred()) SWIG_fail;
17417 }
17418 {
17419 #if wxUSE_UNICODE
17420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17421 #else
17422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17423 #endif
17424 }
17425 {
17426 if (temp1)
17427 delete arg1;
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 {
17434 if (temp3)
17435 delete arg3;
17436 }
17437 return resultobj;
17438 fail:
17439 {
17440 if (temp1)
17441 delete arg1;
17442 }
17443 {
17444 if (temp2)
17445 delete arg2;
17446 }
17447 {
17448 if (temp3)
17449 delete arg3;
17450 }
17451 return NULL;
17452 }
17453
17454
17455 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17456 PyObject *obj;
17457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17458 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17459 return SWIG_Py_Void();
17460 }
17461
17462 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 return SWIG_Python_InitShadowInstance(args);
17464 }
17465
17466 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17467 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17468 return 1;
17469 }
17470
17471
17472 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17473 PyObject *pyobj = 0;
17474
17475 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17476 return pyobj;
17477 }
17478
17479
17480 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj = 0;
17482 wxString *arg1 = 0 ;
17483 wxString *arg2 = 0 ;
17484 bool result;
17485 bool temp1 = false ;
17486 bool temp2 = false ;
17487 PyObject * obj0 = 0 ;
17488 PyObject * obj1 = 0 ;
17489 char * kwnames[] = {
17490 (char *) "mimeType",(char *) "wildcard", NULL
17491 };
17492
17493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17494 {
17495 arg1 = wxString_in_helper(obj0);
17496 if (arg1 == NULL) SWIG_fail;
17497 temp1 = true;
17498 }
17499 {
17500 arg2 = wxString_in_helper(obj1);
17501 if (arg2 == NULL) SWIG_fail;
17502 temp2 = true;
17503 }
17504 {
17505 PyThreadState* __tstate = wxPyBeginAllowThreads();
17506 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 {
17511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17512 }
17513 {
17514 if (temp1)
17515 delete arg1;
17516 }
17517 {
17518 if (temp2)
17519 delete arg2;
17520 }
17521 return resultobj;
17522 fail:
17523 {
17524 if (temp1)
17525 delete arg1;
17526 }
17527 {
17528 if (temp2)
17529 delete arg2;
17530 }
17531 return NULL;
17532 }
17533
17534
17535 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 PyObject *resultobj = 0;
17537 wxMimeTypesManager *result = 0 ;
17538
17539 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17554 PyObject *resultobj = 0;
17555 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17556 int arg2 = (int) wxMAILCAP_ALL ;
17557 wxString const &arg3_defvalue = wxPyEmptyString ;
17558 wxString *arg3 = (wxString *) &arg3_defvalue ;
17559 void *argp1 = 0 ;
17560 int res1 = 0 ;
17561 int val2 ;
17562 int ecode2 = 0 ;
17563 bool temp3 = false ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 PyObject * obj2 = 0 ;
17567 char * kwnames[] = {
17568 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17569 };
17570
17571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17573 if (!SWIG_IsOK(res1)) {
17574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17575 }
17576 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17577 if (obj1) {
17578 ecode2 = SWIG_AsVal_int(obj1, &val2);
17579 if (!SWIG_IsOK(ecode2)) {
17580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17581 }
17582 arg2 = static_cast< int >(val2);
17583 }
17584 if (obj2) {
17585 {
17586 arg3 = wxString_in_helper(obj2);
17587 if (arg3 == NULL) SWIG_fail;
17588 temp3 = true;
17589 }
17590 }
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 resultobj = SWIG_Py_Void();
17598 {
17599 if (temp3)
17600 delete arg3;
17601 }
17602 return resultobj;
17603 fail:
17604 {
17605 if (temp3)
17606 delete arg3;
17607 }
17608 return NULL;
17609 }
17610
17611
17612 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17613 PyObject *resultobj = 0;
17614 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17615 void *argp1 = 0 ;
17616 int res1 = 0 ;
17617 PyObject *swig_obj[1] ;
17618
17619 if (!args) SWIG_fail;
17620 swig_obj[0] = args;
17621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17622 if (!SWIG_IsOK(res1)) {
17623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17624 }
17625 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17626 {
17627 PyThreadState* __tstate = wxPyBeginAllowThreads();
17628 (arg1)->ClearData();
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 resultobj = SWIG_Py_Void();
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = 0;
17641 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17642 wxString *arg2 = 0 ;
17643 wxFileType *result = 0 ;
17644 void *argp1 = 0 ;
17645 int res1 = 0 ;
17646 bool temp2 = false ;
17647 PyObject * obj0 = 0 ;
17648 PyObject * obj1 = 0 ;
17649 char * kwnames[] = {
17650 (char *) "self",(char *) "ext", NULL
17651 };
17652
17653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17655 if (!SWIG_IsOK(res1)) {
17656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17657 }
17658 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17659 {
17660 arg2 = wxString_in_helper(obj1);
17661 if (arg2 == NULL) SWIG_fail;
17662 temp2 = true;
17663 }
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17671 {
17672 if (temp2)
17673 delete arg2;
17674 }
17675 return resultobj;
17676 fail:
17677 {
17678 if (temp2)
17679 delete arg2;
17680 }
17681 return NULL;
17682 }
17683
17684
17685 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj = 0;
17687 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17688 wxString *arg2 = 0 ;
17689 wxFileType *result = 0 ;
17690 void *argp1 = 0 ;
17691 int res1 = 0 ;
17692 bool temp2 = false ;
17693 PyObject * obj0 = 0 ;
17694 PyObject * obj1 = 0 ;
17695 char * kwnames[] = {
17696 (char *) "self",(char *) "mimeType", NULL
17697 };
17698
17699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17701 if (!SWIG_IsOK(res1)) {
17702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17703 }
17704 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17705 {
17706 arg2 = wxString_in_helper(obj1);
17707 if (arg2 == NULL) SWIG_fail;
17708 temp2 = true;
17709 }
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17717 {
17718 if (temp2)
17719 delete arg2;
17720 }
17721 return resultobj;
17722 fail:
17723 {
17724 if (temp2)
17725 delete arg2;
17726 }
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj = 0;
17733 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17734 wxString *arg2 = 0 ;
17735 bool arg3 = (bool) false ;
17736 bool result;
17737 void *argp1 = 0 ;
17738 int res1 = 0 ;
17739 bool temp2 = false ;
17740 bool val3 ;
17741 int ecode3 = 0 ;
17742 PyObject * obj0 = 0 ;
17743 PyObject * obj1 = 0 ;
17744 PyObject * obj2 = 0 ;
17745 char * kwnames[] = {
17746 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17747 };
17748
17749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17751 if (!SWIG_IsOK(res1)) {
17752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17753 }
17754 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17755 {
17756 arg2 = wxString_in_helper(obj1);
17757 if (arg2 == NULL) SWIG_fail;
17758 temp2 = true;
17759 }
17760 if (obj2) {
17761 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17762 if (!SWIG_IsOK(ecode3)) {
17763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17764 }
17765 arg3 = static_cast< bool >(val3);
17766 }
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 {
17774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17775 }
17776 {
17777 if (temp2)
17778 delete arg2;
17779 }
17780 return resultobj;
17781 fail:
17782 {
17783 if (temp2)
17784 delete arg2;
17785 }
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17791 PyObject *resultobj = 0;
17792 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17793 wxString *arg2 = 0 ;
17794 bool result;
17795 void *argp1 = 0 ;
17796 int res1 = 0 ;
17797 bool temp2 = false ;
17798 PyObject * obj0 = 0 ;
17799 PyObject * obj1 = 0 ;
17800 char * kwnames[] = {
17801 (char *) "self",(char *) "filename", NULL
17802 };
17803
17804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17806 if (!SWIG_IsOK(res1)) {
17807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17808 }
17809 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17810 {
17811 arg2 = wxString_in_helper(obj1);
17812 if (arg2 == NULL) SWIG_fail;
17813 temp2 = true;
17814 }
17815 {
17816 PyThreadState* __tstate = wxPyBeginAllowThreads();
17817 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17823 }
17824 {
17825 if (temp2)
17826 delete arg2;
17827 }
17828 return resultobj;
17829 fail:
17830 {
17831 if (temp2)
17832 delete arg2;
17833 }
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *resultobj = 0;
17840 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17841 PyObject *result = 0 ;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 PyObject *swig_obj[1] ;
17845
17846 if (!args) SWIG_fail;
17847 swig_obj[0] = args;
17848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17849 if (!SWIG_IsOK(res1)) {
17850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17851 }
17852 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 resultobj = result;
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17867 PyObject *resultobj = 0;
17868 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17869 wxFileTypeInfo *arg2 = 0 ;
17870 void *argp1 = 0 ;
17871 int res1 = 0 ;
17872 void *argp2 = 0 ;
17873 int res2 = 0 ;
17874 PyObject * obj0 = 0 ;
17875 PyObject * obj1 = 0 ;
17876 char * kwnames[] = {
17877 (char *) "self",(char *) "ft", NULL
17878 };
17879
17880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17882 if (!SWIG_IsOK(res1)) {
17883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17884 }
17885 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17886 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17887 if (!SWIG_IsOK(res2)) {
17888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17889 }
17890 if (!argp2) {
17891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17892 }
17893 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 resultobj = SWIG_Py_Void();
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj = 0;
17909 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17910 wxFileTypeInfo *arg2 = 0 ;
17911 wxFileType *result = 0 ;
17912 void *argp1 = 0 ;
17913 int res1 = 0 ;
17914 void *argp2 = 0 ;
17915 int res2 = 0 ;
17916 PyObject * obj0 = 0 ;
17917 PyObject * obj1 = 0 ;
17918 char * kwnames[] = {
17919 (char *) "self",(char *) "ftInfo", NULL
17920 };
17921
17922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17924 if (!SWIG_IsOK(res1)) {
17925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17926 }
17927 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17929 if (!SWIG_IsOK(res2)) {
17930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17931 }
17932 if (!argp2) {
17933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17934 }
17935 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17936 {
17937 PyThreadState* __tstate = wxPyBeginAllowThreads();
17938 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17943 return resultobj;
17944 fail:
17945 return NULL;
17946 }
17947
17948
17949 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17950 PyObject *resultobj = 0;
17951 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17952 wxFileType *arg2 = (wxFileType *) 0 ;
17953 bool result;
17954 void *argp1 = 0 ;
17955 int res1 = 0 ;
17956 void *argp2 = 0 ;
17957 int res2 = 0 ;
17958 PyObject * obj0 = 0 ;
17959 PyObject * obj1 = 0 ;
17960 char * kwnames[] = {
17961 (char *) "self",(char *) "ft", NULL
17962 };
17963
17964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17968 }
17969 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17971 if (!SWIG_IsOK(res2)) {
17972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17973 }
17974 arg2 = reinterpret_cast< wxFileType * >(argp2);
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (bool)(arg1)->Unassociate(arg2);
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 {
17982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17983 }
17984 return resultobj;
17985 fail:
17986 return NULL;
17987 }
17988
17989
17990 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 PyObject *resultobj = 0;
17992 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17993 void *argp1 = 0 ;
17994 int res1 = 0 ;
17995 PyObject *swig_obj[1] ;
17996
17997 if (!args) SWIG_fail;
17998 swig_obj[0] = args;
17999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18000 if (!SWIG_IsOK(res1)) {
18001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18002 }
18003 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 delete arg1;
18007
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 resultobj = SWIG_Py_Void();
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019 PyObject *obj;
18020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18021 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18022 return SWIG_Py_Void();
18023 }
18024
18025 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18026 return SWIG_Python_InitShadowInstance(args);
18027 }
18028
18029 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18030 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18031 return 1;
18032 }
18033
18034
18035 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18036 PyObject *pyobj = 0;
18037
18038 {
18039 #if wxUSE_UNICODE
18040 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18041 #else
18042 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18043 #endif
18044 }
18045 return pyobj;
18046 }
18047
18048
18049 SWIGINTERN int ART_MENU_set(PyObject *) {
18050 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18051 return 1;
18052 }
18053
18054
18055 SWIGINTERN PyObject *ART_MENU_get(void) {
18056 PyObject *pyobj = 0;
18057
18058 {
18059 #if wxUSE_UNICODE
18060 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18061 #else
18062 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18063 #endif
18064 }
18065 return pyobj;
18066 }
18067
18068
18069 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18070 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18071 return 1;
18072 }
18073
18074
18075 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18076 PyObject *pyobj = 0;
18077
18078 {
18079 #if wxUSE_UNICODE
18080 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18081 #else
18082 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18083 #endif
18084 }
18085 return pyobj;
18086 }
18087
18088
18089 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18090 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18091 return 1;
18092 }
18093
18094
18095 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18096 PyObject *pyobj = 0;
18097
18098 {
18099 #if wxUSE_UNICODE
18100 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18101 #else
18102 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18103 #endif
18104 }
18105 return pyobj;
18106 }
18107
18108
18109 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18110 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18111 return 1;
18112 }
18113
18114
18115 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18116 PyObject *pyobj = 0;
18117
18118 {
18119 #if wxUSE_UNICODE
18120 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18121 #else
18122 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18123 #endif
18124 }
18125 return pyobj;
18126 }
18127
18128
18129 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18130 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18131 return 1;
18132 }
18133
18134
18135 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18136 PyObject *pyobj = 0;
18137
18138 {
18139 #if wxUSE_UNICODE
18140 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18141 #else
18142 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18143 #endif
18144 }
18145 return pyobj;
18146 }
18147
18148
18149 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18150 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18151 return 1;
18152 }
18153
18154
18155 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18156 PyObject *pyobj = 0;
18157
18158 {
18159 #if wxUSE_UNICODE
18160 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18161 #else
18162 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18163 #endif
18164 }
18165 return pyobj;
18166 }
18167
18168
18169 SWIGINTERN int ART_OTHER_set(PyObject *) {
18170 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18171 return 1;
18172 }
18173
18174
18175 SWIGINTERN PyObject *ART_OTHER_get(void) {
18176 PyObject *pyobj = 0;
18177
18178 {
18179 #if wxUSE_UNICODE
18180 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18181 #else
18182 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18183 #endif
18184 }
18185 return pyobj;
18186 }
18187
18188
18189 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18190 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18191 return 1;
18192 }
18193
18194
18195 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18196 PyObject *pyobj = 0;
18197
18198 {
18199 #if wxUSE_UNICODE
18200 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18201 #else
18202 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18203 #endif
18204 }
18205 return pyobj;
18206 }
18207
18208
18209 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18210 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18211 return 1;
18212 }
18213
18214
18215 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18216 PyObject *pyobj = 0;
18217
18218 {
18219 #if wxUSE_UNICODE
18220 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18221 #else
18222 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18223 #endif
18224 }
18225 return pyobj;
18226 }
18227
18228
18229 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18230 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18231 return 1;
18232 }
18233
18234
18235 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18236 PyObject *pyobj = 0;
18237
18238 {
18239 #if wxUSE_UNICODE
18240 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18241 #else
18242 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18243 #endif
18244 }
18245 return pyobj;
18246 }
18247
18248
18249 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18250 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18251 return 1;
18252 }
18253
18254
18255 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18256 PyObject *pyobj = 0;
18257
18258 {
18259 #if wxUSE_UNICODE
18260 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18261 #else
18262 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18263 #endif
18264 }
18265 return pyobj;
18266 }
18267
18268
18269 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18270 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18271 return 1;
18272 }
18273
18274
18275 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18276 PyObject *pyobj = 0;
18277
18278 {
18279 #if wxUSE_UNICODE
18280 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18281 #else
18282 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18283 #endif
18284 }
18285 return pyobj;
18286 }
18287
18288
18289 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18290 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18291 return 1;
18292 }
18293
18294
18295 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18296 PyObject *pyobj = 0;
18297
18298 {
18299 #if wxUSE_UNICODE
18300 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18301 #else
18302 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18303 #endif
18304 }
18305 return pyobj;
18306 }
18307
18308
18309 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18310 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18311 return 1;
18312 }
18313
18314
18315 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18316 PyObject *pyobj = 0;
18317
18318 {
18319 #if wxUSE_UNICODE
18320 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18321 #else
18322 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18323 #endif
18324 }
18325 return pyobj;
18326 }
18327
18328
18329 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18330 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18331 return 1;
18332 }
18333
18334
18335 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18336 PyObject *pyobj = 0;
18337
18338 {
18339 #if wxUSE_UNICODE
18340 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18341 #else
18342 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18343 #endif
18344 }
18345 return pyobj;
18346 }
18347
18348
18349 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18350 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18351 return 1;
18352 }
18353
18354
18355 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18356 PyObject *pyobj = 0;
18357
18358 {
18359 #if wxUSE_UNICODE
18360 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18361 #else
18362 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18363 #endif
18364 }
18365 return pyobj;
18366 }
18367
18368
18369 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18370 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18371 return 1;
18372 }
18373
18374
18375 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18376 PyObject *pyobj = 0;
18377
18378 {
18379 #if wxUSE_UNICODE
18380 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18381 #else
18382 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18383 #endif
18384 }
18385 return pyobj;
18386 }
18387
18388
18389 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18390 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18391 return 1;
18392 }
18393
18394
18395 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18396 PyObject *pyobj = 0;
18397
18398 {
18399 #if wxUSE_UNICODE
18400 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18401 #else
18402 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18403 #endif
18404 }
18405 return pyobj;
18406 }
18407
18408
18409 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18410 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18411 return 1;
18412 }
18413
18414
18415 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18416 PyObject *pyobj = 0;
18417
18418 {
18419 #if wxUSE_UNICODE
18420 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18421 #else
18422 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18423 #endif
18424 }
18425 return pyobj;
18426 }
18427
18428
18429 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18430 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18431 return 1;
18432 }
18433
18434
18435 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18436 PyObject *pyobj = 0;
18437
18438 {
18439 #if wxUSE_UNICODE
18440 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18441 #else
18442 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18443 #endif
18444 }
18445 return pyobj;
18446 }
18447
18448
18449 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18450 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18451 return 1;
18452 }
18453
18454
18455 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18456 PyObject *pyobj = 0;
18457
18458 {
18459 #if wxUSE_UNICODE
18460 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18461 #else
18462 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18463 #endif
18464 }
18465 return pyobj;
18466 }
18467
18468
18469 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18470 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18471 return 1;
18472 }
18473
18474
18475 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18476 PyObject *pyobj = 0;
18477
18478 {
18479 #if wxUSE_UNICODE
18480 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18481 #else
18482 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18483 #endif
18484 }
18485 return pyobj;
18486 }
18487
18488
18489 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18490 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18491 return 1;
18492 }
18493
18494
18495 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18496 PyObject *pyobj = 0;
18497
18498 {
18499 #if wxUSE_UNICODE
18500 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18501 #else
18502 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18503 #endif
18504 }
18505 return pyobj;
18506 }
18507
18508
18509 SWIGINTERN int ART_PRINT_set(PyObject *) {
18510 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18511 return 1;
18512 }
18513
18514
18515 SWIGINTERN PyObject *ART_PRINT_get(void) {
18516 PyObject *pyobj = 0;
18517
18518 {
18519 #if wxUSE_UNICODE
18520 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18521 #else
18522 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18523 #endif
18524 }
18525 return pyobj;
18526 }
18527
18528
18529 SWIGINTERN int ART_HELP_set(PyObject *) {
18530 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18531 return 1;
18532 }
18533
18534
18535 SWIGINTERN PyObject *ART_HELP_get(void) {
18536 PyObject *pyobj = 0;
18537
18538 {
18539 #if wxUSE_UNICODE
18540 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18541 #else
18542 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18543 #endif
18544 }
18545 return pyobj;
18546 }
18547
18548
18549 SWIGINTERN int ART_TIP_set(PyObject *) {
18550 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18551 return 1;
18552 }
18553
18554
18555 SWIGINTERN PyObject *ART_TIP_get(void) {
18556 PyObject *pyobj = 0;
18557
18558 {
18559 #if wxUSE_UNICODE
18560 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18561 #else
18562 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18563 #endif
18564 }
18565 return pyobj;
18566 }
18567
18568
18569 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18570 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18571 return 1;
18572 }
18573
18574
18575 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18576 PyObject *pyobj = 0;
18577
18578 {
18579 #if wxUSE_UNICODE
18580 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18581 #else
18582 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18583 #endif
18584 }
18585 return pyobj;
18586 }
18587
18588
18589 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18590 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18591 return 1;
18592 }
18593
18594
18595 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18596 PyObject *pyobj = 0;
18597
18598 {
18599 #if wxUSE_UNICODE
18600 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18601 #else
18602 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18603 #endif
18604 }
18605 return pyobj;
18606 }
18607
18608
18609 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18610 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18611 return 1;
18612 }
18613
18614
18615 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18616 PyObject *pyobj = 0;
18617
18618 {
18619 #if wxUSE_UNICODE
18620 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18621 #else
18622 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18623 #endif
18624 }
18625 return pyobj;
18626 }
18627
18628
18629 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18630 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18631 return 1;
18632 }
18633
18634
18635 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18636 PyObject *pyobj = 0;
18637
18638 {
18639 #if wxUSE_UNICODE
18640 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18641 #else
18642 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18643 #endif
18644 }
18645 return pyobj;
18646 }
18647
18648
18649 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18650 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18651 return 1;
18652 }
18653
18654
18655 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18656 PyObject *pyobj = 0;
18657
18658 {
18659 #if wxUSE_UNICODE
18660 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18661 #else
18662 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18663 #endif
18664 }
18665 return pyobj;
18666 }
18667
18668
18669 SWIGINTERN int ART_CDROM_set(PyObject *) {
18670 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18671 return 1;
18672 }
18673
18674
18675 SWIGINTERN PyObject *ART_CDROM_get(void) {
18676 PyObject *pyobj = 0;
18677
18678 {
18679 #if wxUSE_UNICODE
18680 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18681 #else
18682 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18683 #endif
18684 }
18685 return pyobj;
18686 }
18687
18688
18689 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18690 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18691 return 1;
18692 }
18693
18694
18695 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18696 PyObject *pyobj = 0;
18697
18698 {
18699 #if wxUSE_UNICODE
18700 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18701 #else
18702 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18703 #endif
18704 }
18705 return pyobj;
18706 }
18707
18708
18709 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18710 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18711 return 1;
18712 }
18713
18714
18715 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18716 PyObject *pyobj = 0;
18717
18718 {
18719 #if wxUSE_UNICODE
18720 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18721 #else
18722 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18723 #endif
18724 }
18725 return pyobj;
18726 }
18727
18728
18729 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18730 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18731 return 1;
18732 }
18733
18734
18735 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18736 PyObject *pyobj = 0;
18737
18738 {
18739 #if wxUSE_UNICODE
18740 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18741 #else
18742 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18743 #endif
18744 }
18745 return pyobj;
18746 }
18747
18748
18749 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18750 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18751 return 1;
18752 }
18753
18754
18755 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18756 PyObject *pyobj = 0;
18757
18758 {
18759 #if wxUSE_UNICODE
18760 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18761 #else
18762 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18763 #endif
18764 }
18765 return pyobj;
18766 }
18767
18768
18769 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18770 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18771 return 1;
18772 }
18773
18774
18775 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18776 PyObject *pyobj = 0;
18777
18778 {
18779 #if wxUSE_UNICODE
18780 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18781 #else
18782 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18783 #endif
18784 }
18785 return pyobj;
18786 }
18787
18788
18789 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18790 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18791 return 1;
18792 }
18793
18794
18795 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18796 PyObject *pyobj = 0;
18797
18798 {
18799 #if wxUSE_UNICODE
18800 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18801 #else
18802 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18803 #endif
18804 }
18805 return pyobj;
18806 }
18807
18808
18809 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18810 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18811 return 1;
18812 }
18813
18814
18815 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18816 PyObject *pyobj = 0;
18817
18818 {
18819 #if wxUSE_UNICODE
18820 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18821 #else
18822 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18823 #endif
18824 }
18825 return pyobj;
18826 }
18827
18828
18829 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18830 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18831 return 1;
18832 }
18833
18834
18835 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18836 PyObject *pyobj = 0;
18837
18838 {
18839 #if wxUSE_UNICODE
18840 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18841 #else
18842 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18843 #endif
18844 }
18845 return pyobj;
18846 }
18847
18848
18849 SWIGINTERN int ART_ERROR_set(PyObject *) {
18850 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18851 return 1;
18852 }
18853
18854
18855 SWIGINTERN PyObject *ART_ERROR_get(void) {
18856 PyObject *pyobj = 0;
18857
18858 {
18859 #if wxUSE_UNICODE
18860 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18861 #else
18862 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18863 #endif
18864 }
18865 return pyobj;
18866 }
18867
18868
18869 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18870 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18871 return 1;
18872 }
18873
18874
18875 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18876 PyObject *pyobj = 0;
18877
18878 {
18879 #if wxUSE_UNICODE
18880 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18881 #else
18882 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18883 #endif
18884 }
18885 return pyobj;
18886 }
18887
18888
18889 SWIGINTERN int ART_WARNING_set(PyObject *) {
18890 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18891 return 1;
18892 }
18893
18894
18895 SWIGINTERN PyObject *ART_WARNING_get(void) {
18896 PyObject *pyobj = 0;
18897
18898 {
18899 #if wxUSE_UNICODE
18900 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18901 #else
18902 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18903 #endif
18904 }
18905 return pyobj;
18906 }
18907
18908
18909 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18910 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18911 return 1;
18912 }
18913
18914
18915 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18916 PyObject *pyobj = 0;
18917
18918 {
18919 #if wxUSE_UNICODE
18920 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18921 #else
18922 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18923 #endif
18924 }
18925 return pyobj;
18926 }
18927
18928
18929 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18930 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18931 return 1;
18932 }
18933
18934
18935 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18936 PyObject *pyobj = 0;
18937
18938 {
18939 #if wxUSE_UNICODE
18940 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18941 #else
18942 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18943 #endif
18944 }
18945 return pyobj;
18946 }
18947
18948
18949 SWIGINTERN int ART_COPY_set(PyObject *) {
18950 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18951 return 1;
18952 }
18953
18954
18955 SWIGINTERN PyObject *ART_COPY_get(void) {
18956 PyObject *pyobj = 0;
18957
18958 {
18959 #if wxUSE_UNICODE
18960 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18961 #else
18962 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18963 #endif
18964 }
18965 return pyobj;
18966 }
18967
18968
18969 SWIGINTERN int ART_CUT_set(PyObject *) {
18970 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18971 return 1;
18972 }
18973
18974
18975 SWIGINTERN PyObject *ART_CUT_get(void) {
18976 PyObject *pyobj = 0;
18977
18978 {
18979 #if wxUSE_UNICODE
18980 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18981 #else
18982 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18983 #endif
18984 }
18985 return pyobj;
18986 }
18987
18988
18989 SWIGINTERN int ART_PASTE_set(PyObject *) {
18990 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18991 return 1;
18992 }
18993
18994
18995 SWIGINTERN PyObject *ART_PASTE_get(void) {
18996 PyObject *pyobj = 0;
18997
18998 {
18999 #if wxUSE_UNICODE
19000 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19001 #else
19002 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19003 #endif
19004 }
19005 return pyobj;
19006 }
19007
19008
19009 SWIGINTERN int ART_DELETE_set(PyObject *) {
19010 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19011 return 1;
19012 }
19013
19014
19015 SWIGINTERN PyObject *ART_DELETE_get(void) {
19016 PyObject *pyobj = 0;
19017
19018 {
19019 #if wxUSE_UNICODE
19020 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19021 #else
19022 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19023 #endif
19024 }
19025 return pyobj;
19026 }
19027
19028
19029 SWIGINTERN int ART_NEW_set(PyObject *) {
19030 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19031 return 1;
19032 }
19033
19034
19035 SWIGINTERN PyObject *ART_NEW_get(void) {
19036 PyObject *pyobj = 0;
19037
19038 {
19039 #if wxUSE_UNICODE
19040 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19041 #else
19042 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19043 #endif
19044 }
19045 return pyobj;
19046 }
19047
19048
19049 SWIGINTERN int ART_UNDO_set(PyObject *) {
19050 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19051 return 1;
19052 }
19053
19054
19055 SWIGINTERN PyObject *ART_UNDO_get(void) {
19056 PyObject *pyobj = 0;
19057
19058 {
19059 #if wxUSE_UNICODE
19060 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19061 #else
19062 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19063 #endif
19064 }
19065 return pyobj;
19066 }
19067
19068
19069 SWIGINTERN int ART_REDO_set(PyObject *) {
19070 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19071 return 1;
19072 }
19073
19074
19075 SWIGINTERN PyObject *ART_REDO_get(void) {
19076 PyObject *pyobj = 0;
19077
19078 {
19079 #if wxUSE_UNICODE
19080 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19081 #else
19082 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19083 #endif
19084 }
19085 return pyobj;
19086 }
19087
19088
19089 SWIGINTERN int ART_QUIT_set(PyObject *) {
19090 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19091 return 1;
19092 }
19093
19094
19095 SWIGINTERN PyObject *ART_QUIT_get(void) {
19096 PyObject *pyobj = 0;
19097
19098 {
19099 #if wxUSE_UNICODE
19100 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19101 #else
19102 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19103 #endif
19104 }
19105 return pyobj;
19106 }
19107
19108
19109 SWIGINTERN int ART_FIND_set(PyObject *) {
19110 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19111 return 1;
19112 }
19113
19114
19115 SWIGINTERN PyObject *ART_FIND_get(void) {
19116 PyObject *pyobj = 0;
19117
19118 {
19119 #if wxUSE_UNICODE
19120 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19121 #else
19122 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19123 #endif
19124 }
19125 return pyobj;
19126 }
19127
19128
19129 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19130 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19131 return 1;
19132 }
19133
19134
19135 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19136 PyObject *pyobj = 0;
19137
19138 {
19139 #if wxUSE_UNICODE
19140 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19141 #else
19142 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19143 #endif
19144 }
19145 return pyobj;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150 PyObject *resultobj = 0;
19151 wxPyArtProvider *result = 0 ;
19152
19153 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19154 {
19155 if (!wxPyCheckForApp()) SWIG_fail;
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = (wxPyArtProvider *)new wxPyArtProvider();
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19169 PyObject *resultobj = 0;
19170 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19171 void *argp1 = 0 ;
19172 int res1 = 0 ;
19173 PyObject *swig_obj[1] ;
19174
19175 if (!args) SWIG_fail;
19176 swig_obj[0] = args;
19177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19180 }
19181 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19182 {
19183 PyThreadState* __tstate = wxPyBeginAllowThreads();
19184 delete arg1;
19185
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 resultobj = SWIG_Py_Void();
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj = 0;
19198 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19199 PyObject *arg2 = (PyObject *) 0 ;
19200 PyObject *arg3 = (PyObject *) 0 ;
19201 void *argp1 = 0 ;
19202 int res1 = 0 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 PyObject * obj2 = 0 ;
19206 char * kwnames[] = {
19207 (char *) "self",(char *) "self",(char *) "_class", NULL
19208 };
19209
19210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19214 }
19215 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19216 arg2 = obj1;
19217 arg3 = obj2;
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 (arg1)->_setCallbackInfo(arg2,arg3);
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 resultobj = SWIG_Py_Void();
19225 return resultobj;
19226 fail:
19227 return NULL;
19228 }
19229
19230
19231 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj = 0;
19233 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19234 int res1 = 0 ;
19235 PyObject * obj0 = 0 ;
19236 char * kwnames[] = {
19237 (char *) "provider", NULL
19238 };
19239
19240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19241 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19242 if (!SWIG_IsOK(res1)) {
19243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19244 }
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 wxPyArtProvider::PushProvider(arg1);
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = SWIG_Py_Void();
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19259 PyObject *resultobj = 0;
19260 bool result;
19261
19262 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (bool)wxPyArtProvider::PopProvider();
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj = 0;
19280 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19281 bool result;
19282 void *argp1 = 0 ;
19283 int res1 = 0 ;
19284 PyObject * obj0 = 0 ;
19285 char * kwnames[] = {
19286 (char *) "provider", NULL
19287 };
19288
19289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19291 if (!SWIG_IsOK(res1)) {
19292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19293 }
19294 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj = 0;
19312 wxString *arg1 = 0 ;
19313 wxString const &arg2_defvalue = wxPyART_OTHER ;
19314 wxString *arg2 = (wxString *) &arg2_defvalue ;
19315 wxSize const &arg3_defvalue = wxDefaultSize ;
19316 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19317 wxBitmap result;
19318 bool temp1 = false ;
19319 bool temp2 = false ;
19320 wxSize temp3 ;
19321 PyObject * obj0 = 0 ;
19322 PyObject * obj1 = 0 ;
19323 PyObject * obj2 = 0 ;
19324 char * kwnames[] = {
19325 (char *) "id",(char *) "client",(char *) "size", NULL
19326 };
19327
19328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19329 {
19330 arg1 = wxString_in_helper(obj0);
19331 if (arg1 == NULL) SWIG_fail;
19332 temp1 = true;
19333 }
19334 if (obj1) {
19335 {
19336 arg2 = wxString_in_helper(obj1);
19337 if (arg2 == NULL) SWIG_fail;
19338 temp2 = true;
19339 }
19340 }
19341 if (obj2) {
19342 {
19343 arg3 = &temp3;
19344 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19345 }
19346 }
19347 {
19348 if (!wxPyCheckForApp()) SWIG_fail;
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19355 {
19356 if (temp1)
19357 delete arg1;
19358 }
19359 {
19360 if (temp2)
19361 delete arg2;
19362 }
19363 return resultobj;
19364 fail:
19365 {
19366 if (temp1)
19367 delete arg1;
19368 }
19369 {
19370 if (temp2)
19371 delete arg2;
19372 }
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19378 PyObject *resultobj = 0;
19379 wxString *arg1 = 0 ;
19380 wxString const &arg2_defvalue = wxPyART_OTHER ;
19381 wxString *arg2 = (wxString *) &arg2_defvalue ;
19382 wxSize const &arg3_defvalue = wxDefaultSize ;
19383 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19384 wxIcon result;
19385 bool temp1 = false ;
19386 bool temp2 = false ;
19387 wxSize temp3 ;
19388 PyObject * obj0 = 0 ;
19389 PyObject * obj1 = 0 ;
19390 PyObject * obj2 = 0 ;
19391 char * kwnames[] = {
19392 (char *) "id",(char *) "client",(char *) "size", NULL
19393 };
19394
19395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19396 {
19397 arg1 = wxString_in_helper(obj0);
19398 if (arg1 == NULL) SWIG_fail;
19399 temp1 = true;
19400 }
19401 if (obj1) {
19402 {
19403 arg2 = wxString_in_helper(obj1);
19404 if (arg2 == NULL) SWIG_fail;
19405 temp2 = true;
19406 }
19407 }
19408 if (obj2) {
19409 {
19410 arg3 = &temp3;
19411 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19412 }
19413 }
19414 {
19415 if (!wxPyCheckForApp()) SWIG_fail;
19416 PyThreadState* __tstate = wxPyBeginAllowThreads();
19417 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19422 {
19423 if (temp1)
19424 delete arg1;
19425 }
19426 {
19427 if (temp2)
19428 delete arg2;
19429 }
19430 return resultobj;
19431 fail:
19432 {
19433 if (temp1)
19434 delete arg1;
19435 }
19436 {
19437 if (temp2)
19438 delete arg2;
19439 }
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj = 0;
19446 wxString *arg1 = 0 ;
19447 bool arg2 = (bool) false ;
19448 wxSize result;
19449 bool temp1 = false ;
19450 bool val2 ;
19451 int ecode2 = 0 ;
19452 PyObject * obj0 = 0 ;
19453 PyObject * obj1 = 0 ;
19454 char * kwnames[] = {
19455 (char *) "client",(char *) "platform_dependent", NULL
19456 };
19457
19458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19459 {
19460 arg1 = wxString_in_helper(obj0);
19461 if (arg1 == NULL) SWIG_fail;
19462 temp1 = true;
19463 }
19464 if (obj1) {
19465 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19466 if (!SWIG_IsOK(ecode2)) {
19467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19468 }
19469 arg2 = static_cast< bool >(val2);
19470 }
19471 {
19472 PyThreadState* __tstate = wxPyBeginAllowThreads();
19473 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19474 wxPyEndAllowThreads(__tstate);
19475 if (PyErr_Occurred()) SWIG_fail;
19476 }
19477 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19478 {
19479 if (temp1)
19480 delete arg1;
19481 }
19482 return resultobj;
19483 fail:
19484 {
19485 if (temp1)
19486 delete arg1;
19487 }
19488 return NULL;
19489 }
19490
19491
19492 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 PyObject *resultobj = 0;
19494 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19495 void *argp1 = 0 ;
19496 int res1 = 0 ;
19497 PyObject *swig_obj[1] ;
19498
19499 if (!args) SWIG_fail;
19500 swig_obj[0] = args;
19501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19502 if (!SWIG_IsOK(res1)) {
19503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19504 }
19505 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 wxPyArtProvider_Destroy(arg1);
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_Py_Void();
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19520 PyObject *obj;
19521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19522 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19523 return SWIG_Py_Void();
19524 }
19525
19526 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527 return SWIG_Python_InitShadowInstance(args);
19528 }
19529
19530 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19531 PyObject *resultobj = 0;
19532 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19533 void *argp1 = 0 ;
19534 int res1 = 0 ;
19535 PyObject *swig_obj[1] ;
19536
19537 if (!args) SWIG_fail;
19538 swig_obj[0] = args;
19539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19542 }
19543 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 delete arg1;
19547
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 resultobj = SWIG_Py_Void();
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj = 0;
19560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19561 wxConfigBase *result = 0 ;
19562 int res1 = 0 ;
19563 PyObject * obj0 = 0 ;
19564 char * kwnames[] = {
19565 (char *) "config", NULL
19566 };
19567
19568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19569 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19572 }
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj = 0;
19588 bool arg1 = (bool) true ;
19589 wxConfigBase *result = 0 ;
19590 bool val1 ;
19591 int ecode1 = 0 ;
19592 PyObject * obj0 = 0 ;
19593 char * kwnames[] = {
19594 (char *) "createOnDemand", NULL
19595 };
19596
19597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19598 if (obj0) {
19599 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19600 if (!SWIG_IsOK(ecode1)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19602 }
19603 arg1 = static_cast< bool >(val1);
19604 }
19605 {
19606 PyThreadState* __tstate = wxPyBeginAllowThreads();
19607 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19608 wxPyEndAllowThreads(__tstate);
19609 if (PyErr_Occurred()) SWIG_fail;
19610 }
19611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19612 return resultobj;
19613 fail:
19614 return NULL;
19615 }
19616
19617
19618 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19619 PyObject *resultobj = 0;
19620 wxConfigBase *result = 0 ;
19621
19622 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19623 {
19624 PyThreadState* __tstate = wxPyBeginAllowThreads();
19625 result = (wxConfigBase *)wxConfigBase::Create();
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19637 PyObject *resultobj = 0;
19638
19639 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 wxConfigBase::DontCreateOnDemand();
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_Py_Void();
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = 0;
19655 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19656 wxString *arg2 = 0 ;
19657 void *argp1 = 0 ;
19658 int res1 = 0 ;
19659 bool temp2 = false ;
19660 PyObject * obj0 = 0 ;
19661 PyObject * obj1 = 0 ;
19662 char * kwnames[] = {
19663 (char *) "self",(char *) "path", NULL
19664 };
19665
19666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19668 if (!SWIG_IsOK(res1)) {
19669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19670 }
19671 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19672 {
19673 arg2 = wxString_in_helper(obj1);
19674 if (arg2 == NULL) SWIG_fail;
19675 temp2 = true;
19676 }
19677 {
19678 PyThreadState* __tstate = wxPyBeginAllowThreads();
19679 (arg1)->SetPath((wxString const &)*arg2);
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_Py_Void();
19684 {
19685 if (temp2)
19686 delete arg2;
19687 }
19688 return resultobj;
19689 fail:
19690 {
19691 if (temp2)
19692 delete arg2;
19693 }
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19701 wxString *result = 0 ;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 {
19716 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19717 result = (wxString *) &_result_ref;
19718 }
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 {
19723 #if wxUSE_UNICODE
19724 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19725 #else
19726 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19727 #endif
19728 }
19729 return resultobj;
19730 fail:
19731 return NULL;
19732 }
19733
19734
19735 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19736 PyObject *resultobj = 0;
19737 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19738 PyObject *result = 0 ;
19739 void *argp1 = 0 ;
19740 int res1 = 0 ;
19741 PyObject *swig_obj[1] ;
19742
19743 if (!args) SWIG_fail;
19744 swig_obj[0] = args;
19745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19746 if (!SWIG_IsOK(res1)) {
19747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19748 }
19749 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19750 {
19751 PyThreadState* __tstate = wxPyBeginAllowThreads();
19752 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 resultobj = result;
19757 return resultobj;
19758 fail:
19759 return NULL;
19760 }
19761
19762
19763 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19764 PyObject *resultobj = 0;
19765 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19766 long arg2 ;
19767 PyObject *result = 0 ;
19768 void *argp1 = 0 ;
19769 int res1 = 0 ;
19770 long val2 ;
19771 int ecode2 = 0 ;
19772 PyObject * obj0 = 0 ;
19773 PyObject * obj1 = 0 ;
19774 char * kwnames[] = {
19775 (char *) "self",(char *) "index", NULL
19776 };
19777
19778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19780 if (!SWIG_IsOK(res1)) {
19781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19782 }
19783 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19784 ecode2 = SWIG_AsVal_long(obj1, &val2);
19785 if (!SWIG_IsOK(ecode2)) {
19786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19787 }
19788 arg2 = static_cast< long >(val2);
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = result;
19796 return resultobj;
19797 fail:
19798 return NULL;
19799 }
19800
19801
19802 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19803 PyObject *resultobj = 0;
19804 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19805 PyObject *result = 0 ;
19806 void *argp1 = 0 ;
19807 int res1 = 0 ;
19808 PyObject *swig_obj[1] ;
19809
19810 if (!args) SWIG_fail;
19811 swig_obj[0] = args;
19812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19813 if (!SWIG_IsOK(res1)) {
19814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19815 }
19816 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19817 {
19818 PyThreadState* __tstate = wxPyBeginAllowThreads();
19819 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19820 wxPyEndAllowThreads(__tstate);
19821 if (PyErr_Occurred()) SWIG_fail;
19822 }
19823 resultobj = result;
19824 return resultobj;
19825 fail:
19826 return NULL;
19827 }
19828
19829
19830 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19831 PyObject *resultobj = 0;
19832 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19833 long arg2 ;
19834 PyObject *result = 0 ;
19835 void *argp1 = 0 ;
19836 int res1 = 0 ;
19837 long val2 ;
19838 int ecode2 = 0 ;
19839 PyObject * obj0 = 0 ;
19840 PyObject * obj1 = 0 ;
19841 char * kwnames[] = {
19842 (char *) "self",(char *) "index", NULL
19843 };
19844
19845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19847 if (!SWIG_IsOK(res1)) {
19848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19849 }
19850 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19851 ecode2 = SWIG_AsVal_long(obj1, &val2);
19852 if (!SWIG_IsOK(ecode2)) {
19853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19854 }
19855 arg2 = static_cast< long >(val2);
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 resultobj = result;
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19870 PyObject *resultobj = 0;
19871 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19872 bool arg2 = (bool) false ;
19873 size_t result;
19874 void *argp1 = 0 ;
19875 int res1 = 0 ;
19876 bool val2 ;
19877 int ecode2 = 0 ;
19878 PyObject * obj0 = 0 ;
19879 PyObject * obj1 = 0 ;
19880 char * kwnames[] = {
19881 (char *) "self",(char *) "recursive", NULL
19882 };
19883
19884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19886 if (!SWIG_IsOK(res1)) {
19887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19888 }
19889 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19890 if (obj1) {
19891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19892 if (!SWIG_IsOK(ecode2)) {
19893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19894 }
19895 arg2 = static_cast< bool >(val2);
19896 }
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj = 0;
19912 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19913 bool arg2 = (bool) false ;
19914 size_t result;
19915 void *argp1 = 0 ;
19916 int res1 = 0 ;
19917 bool val2 ;
19918 int ecode2 = 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char * kwnames[] = {
19922 (char *) "self",(char *) "recursive", NULL
19923 };
19924
19925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19929 }
19930 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19931 if (obj1) {
19932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19933 if (!SWIG_IsOK(ecode2)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19935 }
19936 arg2 = static_cast< bool >(val2);
19937 }
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj = 0;
19953 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19954 wxString *arg2 = 0 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 bool temp2 = false ;
19959 PyObject * obj0 = 0 ;
19960 PyObject * obj1 = 0 ;
19961 char * kwnames[] = {
19962 (char *) "self",(char *) "name", NULL
19963 };
19964
19965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19967 if (!SWIG_IsOK(res1)) {
19968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19969 }
19970 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19971 {
19972 arg2 = wxString_in_helper(obj1);
19973 if (arg2 == NULL) SWIG_fail;
19974 temp2 = true;
19975 }
19976 {
19977 PyThreadState* __tstate = wxPyBeginAllowThreads();
19978 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19979 wxPyEndAllowThreads(__tstate);
19980 if (PyErr_Occurred()) SWIG_fail;
19981 }
19982 {
19983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19984 }
19985 {
19986 if (temp2)
19987 delete arg2;
19988 }
19989 return resultobj;
19990 fail:
19991 {
19992 if (temp2)
19993 delete arg2;
19994 }
19995 return NULL;
19996 }
19997
19998
19999 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20000 PyObject *resultobj = 0;
20001 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20002 wxString *arg2 = 0 ;
20003 bool result;
20004 void *argp1 = 0 ;
20005 int res1 = 0 ;
20006 bool temp2 = false ;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 char * kwnames[] = {
20010 (char *) "self",(char *) "name", NULL
20011 };
20012
20013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20015 if (!SWIG_IsOK(res1)) {
20016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20017 }
20018 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20019 {
20020 arg2 = wxString_in_helper(obj1);
20021 if (arg2 == NULL) SWIG_fail;
20022 temp2 = true;
20023 }
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20027 wxPyEndAllowThreads(__tstate);
20028 if (PyErr_Occurred()) SWIG_fail;
20029 }
20030 {
20031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20032 }
20033 {
20034 if (temp2)
20035 delete arg2;
20036 }
20037 return resultobj;
20038 fail:
20039 {
20040 if (temp2)
20041 delete arg2;
20042 }
20043 return NULL;
20044 }
20045
20046
20047 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20048 PyObject *resultobj = 0;
20049 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20050 wxString *arg2 = 0 ;
20051 bool result;
20052 void *argp1 = 0 ;
20053 int res1 = 0 ;
20054 bool temp2 = false ;
20055 PyObject * obj0 = 0 ;
20056 PyObject * obj1 = 0 ;
20057 char * kwnames[] = {
20058 (char *) "self",(char *) "name", NULL
20059 };
20060
20061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20063 if (!SWIG_IsOK(res1)) {
20064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20065 }
20066 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20067 {
20068 arg2 = wxString_in_helper(obj1);
20069 if (arg2 == NULL) SWIG_fail;
20070 temp2 = true;
20071 }
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20080 }
20081 {
20082 if (temp2)
20083 delete arg2;
20084 }
20085 return resultobj;
20086 fail:
20087 {
20088 if (temp2)
20089 delete arg2;
20090 }
20091 return NULL;
20092 }
20093
20094
20095 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj = 0;
20097 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20098 wxString *arg2 = 0 ;
20099 wxConfigBase::EntryType result;
20100 void *argp1 = 0 ;
20101 int res1 = 0 ;
20102 bool temp2 = false ;
20103 PyObject * obj0 = 0 ;
20104 PyObject * obj1 = 0 ;
20105 char * kwnames[] = {
20106 (char *) "self",(char *) "name", NULL
20107 };
20108
20109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20111 if (!SWIG_IsOK(res1)) {
20112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20113 }
20114 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20115 {
20116 arg2 = wxString_in_helper(obj1);
20117 if (arg2 == NULL) SWIG_fail;
20118 temp2 = true;
20119 }
20120 {
20121 PyThreadState* __tstate = wxPyBeginAllowThreads();
20122 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20123 wxPyEndAllowThreads(__tstate);
20124 if (PyErr_Occurred()) SWIG_fail;
20125 }
20126 resultobj = SWIG_From_int(static_cast< int >(result));
20127 {
20128 if (temp2)
20129 delete arg2;
20130 }
20131 return resultobj;
20132 fail:
20133 {
20134 if (temp2)
20135 delete arg2;
20136 }
20137 return NULL;
20138 }
20139
20140
20141 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20142 PyObject *resultobj = 0;
20143 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20144 wxString *arg2 = 0 ;
20145 wxString const &arg3_defvalue = wxPyEmptyString ;
20146 wxString *arg3 = (wxString *) &arg3_defvalue ;
20147 wxString result;
20148 void *argp1 = 0 ;
20149 int res1 = 0 ;
20150 bool temp2 = false ;
20151 bool temp3 = false ;
20152 PyObject * obj0 = 0 ;
20153 PyObject * obj1 = 0 ;
20154 PyObject * obj2 = 0 ;
20155 char * kwnames[] = {
20156 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20157 };
20158
20159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20161 if (!SWIG_IsOK(res1)) {
20162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20163 }
20164 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20165 {
20166 arg2 = wxString_in_helper(obj1);
20167 if (arg2 == NULL) SWIG_fail;
20168 temp2 = true;
20169 }
20170 if (obj2) {
20171 {
20172 arg3 = wxString_in_helper(obj2);
20173 if (arg3 == NULL) SWIG_fail;
20174 temp3 = true;
20175 }
20176 }
20177 {
20178 PyThreadState* __tstate = wxPyBeginAllowThreads();
20179 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 {
20184 #if wxUSE_UNICODE
20185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20186 #else
20187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20188 #endif
20189 }
20190 {
20191 if (temp2)
20192 delete arg2;
20193 }
20194 {
20195 if (temp3)
20196 delete arg3;
20197 }
20198 return resultobj;
20199 fail:
20200 {
20201 if (temp2)
20202 delete arg2;
20203 }
20204 {
20205 if (temp3)
20206 delete arg3;
20207 }
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj = 0;
20214 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20215 wxString *arg2 = 0 ;
20216 long arg3 = (long) 0 ;
20217 long result;
20218 void *argp1 = 0 ;
20219 int res1 = 0 ;
20220 bool temp2 = false ;
20221 long val3 ;
20222 int ecode3 = 0 ;
20223 PyObject * obj0 = 0 ;
20224 PyObject * obj1 = 0 ;
20225 PyObject * obj2 = 0 ;
20226 char * kwnames[] = {
20227 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20228 };
20229
20230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20232 if (!SWIG_IsOK(res1)) {
20233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20234 }
20235 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20236 {
20237 arg2 = wxString_in_helper(obj1);
20238 if (arg2 == NULL) SWIG_fail;
20239 temp2 = true;
20240 }
20241 if (obj2) {
20242 ecode3 = SWIG_AsVal_long(obj2, &val3);
20243 if (!SWIG_IsOK(ecode3)) {
20244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20245 }
20246 arg3 = static_cast< long >(val3);
20247 }
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 resultobj = SWIG_From_long(static_cast< long >(result));
20255 {
20256 if (temp2)
20257 delete arg2;
20258 }
20259 return resultobj;
20260 fail:
20261 {
20262 if (temp2)
20263 delete arg2;
20264 }
20265 return NULL;
20266 }
20267
20268
20269 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj = 0;
20271 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20272 wxString *arg2 = 0 ;
20273 double arg3 = (double) 0.0 ;
20274 double result;
20275 void *argp1 = 0 ;
20276 int res1 = 0 ;
20277 bool temp2 = false ;
20278 double val3 ;
20279 int ecode3 = 0 ;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 PyObject * obj2 = 0 ;
20283 char * kwnames[] = {
20284 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20285 };
20286
20287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20291 }
20292 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20293 {
20294 arg2 = wxString_in_helper(obj1);
20295 if (arg2 == NULL) SWIG_fail;
20296 temp2 = true;
20297 }
20298 if (obj2) {
20299 ecode3 = SWIG_AsVal_double(obj2, &val3);
20300 if (!SWIG_IsOK(ecode3)) {
20301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20302 }
20303 arg3 = static_cast< double >(val3);
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_From_double(static_cast< double >(result));
20312 {
20313 if (temp2)
20314 delete arg2;
20315 }
20316 return resultobj;
20317 fail:
20318 {
20319 if (temp2)
20320 delete arg2;
20321 }
20322 return NULL;
20323 }
20324
20325
20326 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj = 0;
20328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20329 wxString *arg2 = 0 ;
20330 bool arg3 = (bool) false ;
20331 bool result;
20332 void *argp1 = 0 ;
20333 int res1 = 0 ;
20334 bool temp2 = false ;
20335 bool val3 ;
20336 int ecode3 = 0 ;
20337 PyObject * obj0 = 0 ;
20338 PyObject * obj1 = 0 ;
20339 PyObject * obj2 = 0 ;
20340 char * kwnames[] = {
20341 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20342 };
20343
20344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20346 if (!SWIG_IsOK(res1)) {
20347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20348 }
20349 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20350 {
20351 arg2 = wxString_in_helper(obj1);
20352 if (arg2 == NULL) SWIG_fail;
20353 temp2 = true;
20354 }
20355 if (obj2) {
20356 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20357 if (!SWIG_IsOK(ecode3)) {
20358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20359 }
20360 arg3 = static_cast< bool >(val3);
20361 }
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 {
20369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20370 }
20371 {
20372 if (temp2)
20373 delete arg2;
20374 }
20375 return resultobj;
20376 fail:
20377 {
20378 if (temp2)
20379 delete arg2;
20380 }
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20386 PyObject *resultobj = 0;
20387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20388 wxString *arg2 = 0 ;
20389 wxString *arg3 = 0 ;
20390 bool result;
20391 void *argp1 = 0 ;
20392 int res1 = 0 ;
20393 bool temp2 = false ;
20394 bool temp3 = false ;
20395 PyObject * obj0 = 0 ;
20396 PyObject * obj1 = 0 ;
20397 PyObject * obj2 = 0 ;
20398 char * kwnames[] = {
20399 (char *) "self",(char *) "key",(char *) "value", NULL
20400 };
20401
20402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20404 if (!SWIG_IsOK(res1)) {
20405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20406 }
20407 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20408 {
20409 arg2 = wxString_in_helper(obj1);
20410 if (arg2 == NULL) SWIG_fail;
20411 temp2 = true;
20412 }
20413 {
20414 arg3 = wxString_in_helper(obj2);
20415 if (arg3 == NULL) SWIG_fail;
20416 temp3 = true;
20417 }
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 {
20425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20426 }
20427 {
20428 if (temp2)
20429 delete arg2;
20430 }
20431 {
20432 if (temp3)
20433 delete arg3;
20434 }
20435 return resultobj;
20436 fail:
20437 {
20438 if (temp2)
20439 delete arg2;
20440 }
20441 {
20442 if (temp3)
20443 delete arg3;
20444 }
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20450 PyObject *resultobj = 0;
20451 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20452 wxString *arg2 = 0 ;
20453 long arg3 ;
20454 bool result;
20455 void *argp1 = 0 ;
20456 int res1 = 0 ;
20457 bool temp2 = false ;
20458 long val3 ;
20459 int ecode3 = 0 ;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 PyObject * obj2 = 0 ;
20463 char * kwnames[] = {
20464 (char *) "self",(char *) "key",(char *) "value", NULL
20465 };
20466
20467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20469 if (!SWIG_IsOK(res1)) {
20470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20471 }
20472 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20473 {
20474 arg2 = wxString_in_helper(obj1);
20475 if (arg2 == NULL) SWIG_fail;
20476 temp2 = true;
20477 }
20478 ecode3 = SWIG_AsVal_long(obj2, &val3);
20479 if (!SWIG_IsOK(ecode3)) {
20480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20481 }
20482 arg3 = static_cast< long >(val3);
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 {
20490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20491 }
20492 {
20493 if (temp2)
20494 delete arg2;
20495 }
20496 return resultobj;
20497 fail:
20498 {
20499 if (temp2)
20500 delete arg2;
20501 }
20502 return NULL;
20503 }
20504
20505
20506 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20507 PyObject *resultobj = 0;
20508 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20509 wxString *arg2 = 0 ;
20510 double arg3 ;
20511 bool result;
20512 void *argp1 = 0 ;
20513 int res1 = 0 ;
20514 bool temp2 = false ;
20515 double val3 ;
20516 int ecode3 = 0 ;
20517 PyObject * obj0 = 0 ;
20518 PyObject * obj1 = 0 ;
20519 PyObject * obj2 = 0 ;
20520 char * kwnames[] = {
20521 (char *) "self",(char *) "key",(char *) "value", NULL
20522 };
20523
20524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20526 if (!SWIG_IsOK(res1)) {
20527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20528 }
20529 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20530 {
20531 arg2 = wxString_in_helper(obj1);
20532 if (arg2 == NULL) SWIG_fail;
20533 temp2 = true;
20534 }
20535 ecode3 = SWIG_AsVal_double(obj2, &val3);
20536 if (!SWIG_IsOK(ecode3)) {
20537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20538 }
20539 arg3 = static_cast< double >(val3);
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 {
20547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20548 }
20549 {
20550 if (temp2)
20551 delete arg2;
20552 }
20553 return resultobj;
20554 fail:
20555 {
20556 if (temp2)
20557 delete arg2;
20558 }
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20564 PyObject *resultobj = 0;
20565 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20566 wxString *arg2 = 0 ;
20567 bool arg3 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 bool temp2 = false ;
20572 bool val3 ;
20573 int ecode3 = 0 ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 PyObject * obj2 = 0 ;
20577 char * kwnames[] = {
20578 (char *) "self",(char *) "key",(char *) "value", NULL
20579 };
20580
20581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20585 }
20586 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20587 {
20588 arg2 = wxString_in_helper(obj1);
20589 if (arg2 == NULL) SWIG_fail;
20590 temp2 = true;
20591 }
20592 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20593 if (!SWIG_IsOK(ecode3)) {
20594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20595 }
20596 arg3 = static_cast< bool >(val3);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 {
20607 if (temp2)
20608 delete arg2;
20609 }
20610 return resultobj;
20611 fail:
20612 {
20613 if (temp2)
20614 delete arg2;
20615 }
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20623 bool arg2 = (bool) false ;
20624 bool result;
20625 void *argp1 = 0 ;
20626 int res1 = 0 ;
20627 bool val2 ;
20628 int ecode2 = 0 ;
20629 PyObject * obj0 = 0 ;
20630 PyObject * obj1 = 0 ;
20631 char * kwnames[] = {
20632 (char *) "self",(char *) "currentOnly", NULL
20633 };
20634
20635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20639 }
20640 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20641 if (obj1) {
20642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20643 if (!SWIG_IsOK(ecode2)) {
20644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20645 }
20646 arg2 = static_cast< bool >(val2);
20647 }
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)(arg1)->Flush(arg2);
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj = 0;
20665 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20666 wxString *arg2 = 0 ;
20667 wxString *arg3 = 0 ;
20668 bool result;
20669 void *argp1 = 0 ;
20670 int res1 = 0 ;
20671 bool temp2 = false ;
20672 bool temp3 = false ;
20673 PyObject * obj0 = 0 ;
20674 PyObject * obj1 = 0 ;
20675 PyObject * obj2 = 0 ;
20676 char * kwnames[] = {
20677 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20678 };
20679
20680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20684 }
20685 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20686 {
20687 arg2 = wxString_in_helper(obj1);
20688 if (arg2 == NULL) SWIG_fail;
20689 temp2 = true;
20690 }
20691 {
20692 arg3 = wxString_in_helper(obj2);
20693 if (arg3 == NULL) SWIG_fail;
20694 temp3 = true;
20695 }
20696 {
20697 PyThreadState* __tstate = wxPyBeginAllowThreads();
20698 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20704 }
20705 {
20706 if (temp2)
20707 delete arg2;
20708 }
20709 {
20710 if (temp3)
20711 delete arg3;
20712 }
20713 return resultobj;
20714 fail:
20715 {
20716 if (temp2)
20717 delete arg2;
20718 }
20719 {
20720 if (temp3)
20721 delete arg3;
20722 }
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20728 PyObject *resultobj = 0;
20729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20730 wxString *arg2 = 0 ;
20731 wxString *arg3 = 0 ;
20732 bool result;
20733 void *argp1 = 0 ;
20734 int res1 = 0 ;
20735 bool temp2 = false ;
20736 bool temp3 = false ;
20737 PyObject * obj0 = 0 ;
20738 PyObject * obj1 = 0 ;
20739 PyObject * obj2 = 0 ;
20740 char * kwnames[] = {
20741 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20742 };
20743
20744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20746 if (!SWIG_IsOK(res1)) {
20747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20748 }
20749 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20750 {
20751 arg2 = wxString_in_helper(obj1);
20752 if (arg2 == NULL) SWIG_fail;
20753 temp2 = true;
20754 }
20755 {
20756 arg3 = wxString_in_helper(obj2);
20757 if (arg3 == NULL) SWIG_fail;
20758 temp3 = true;
20759 }
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20768 }
20769 {
20770 if (temp2)
20771 delete arg2;
20772 }
20773 {
20774 if (temp3)
20775 delete arg3;
20776 }
20777 return resultobj;
20778 fail:
20779 {
20780 if (temp2)
20781 delete arg2;
20782 }
20783 {
20784 if (temp3)
20785 delete arg3;
20786 }
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20792 PyObject *resultobj = 0;
20793 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20794 wxString *arg2 = 0 ;
20795 bool arg3 = (bool) true ;
20796 bool result;
20797 void *argp1 = 0 ;
20798 int res1 = 0 ;
20799 bool temp2 = false ;
20800 bool val3 ;
20801 int ecode3 = 0 ;
20802 PyObject * obj0 = 0 ;
20803 PyObject * obj1 = 0 ;
20804 PyObject * obj2 = 0 ;
20805 char * kwnames[] = {
20806 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20807 };
20808
20809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20813 }
20814 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20815 {
20816 arg2 = wxString_in_helper(obj1);
20817 if (arg2 == NULL) SWIG_fail;
20818 temp2 = true;
20819 }
20820 if (obj2) {
20821 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20822 if (!SWIG_IsOK(ecode3)) {
20823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20824 }
20825 arg3 = static_cast< bool >(val3);
20826 }
20827 {
20828 PyThreadState* __tstate = wxPyBeginAllowThreads();
20829 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 {
20834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20835 }
20836 {
20837 if (temp2)
20838 delete arg2;
20839 }
20840 return resultobj;
20841 fail:
20842 {
20843 if (temp2)
20844 delete arg2;
20845 }
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20851 PyObject *resultobj = 0;
20852 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20853 wxString *arg2 = 0 ;
20854 bool result;
20855 void *argp1 = 0 ;
20856 int res1 = 0 ;
20857 bool temp2 = false ;
20858 PyObject * obj0 = 0 ;
20859 PyObject * obj1 = 0 ;
20860 char * kwnames[] = {
20861 (char *) "self",(char *) "key", NULL
20862 };
20863
20864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20866 if (!SWIG_IsOK(res1)) {
20867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20868 }
20869 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20870 {
20871 arg2 = wxString_in_helper(obj1);
20872 if (arg2 == NULL) SWIG_fail;
20873 temp2 = true;
20874 }
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 {
20885 if (temp2)
20886 delete arg2;
20887 }
20888 return resultobj;
20889 fail:
20890 {
20891 if (temp2)
20892 delete arg2;
20893 }
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899 PyObject *resultobj = 0;
20900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20901 bool result;
20902 void *argp1 = 0 ;
20903 int res1 = 0 ;
20904 PyObject *swig_obj[1] ;
20905
20906 if (!args) SWIG_fail;
20907 swig_obj[0] = args;
20908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20909 if (!SWIG_IsOK(res1)) {
20910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20911 }
20912 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (bool)(arg1)->DeleteAll();
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 {
20920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20921 }
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj = 0;
20930 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20931 bool arg2 = (bool) true ;
20932 void *argp1 = 0 ;
20933 int res1 = 0 ;
20934 bool val2 ;
20935 int ecode2 = 0 ;
20936 PyObject * obj0 = 0 ;
20937 PyObject * obj1 = 0 ;
20938 char * kwnames[] = {
20939 (char *) "self",(char *) "doIt", NULL
20940 };
20941
20942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20944 if (!SWIG_IsOK(res1)) {
20945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20946 }
20947 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20948 if (obj1) {
20949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20950 if (!SWIG_IsOK(ecode2)) {
20951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20952 }
20953 arg2 = static_cast< bool >(val2);
20954 }
20955 {
20956 PyThreadState* __tstate = wxPyBeginAllowThreads();
20957 (arg1)->SetExpandEnvVars(arg2);
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 resultobj = SWIG_Py_Void();
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20969 PyObject *resultobj = 0;
20970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20971 bool result;
20972 void *argp1 = 0 ;
20973 int res1 = 0 ;
20974 PyObject *swig_obj[1] ;
20975
20976 if (!args) SWIG_fail;
20977 swig_obj[0] = args;
20978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20979 if (!SWIG_IsOK(res1)) {
20980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20981 }
20982 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj = 0;
21000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21001 bool arg2 = (bool) true ;
21002 void *argp1 = 0 ;
21003 int res1 = 0 ;
21004 bool val2 ;
21005 int ecode2 = 0 ;
21006 PyObject * obj0 = 0 ;
21007 PyObject * obj1 = 0 ;
21008 char * kwnames[] = {
21009 (char *) "self",(char *) "doIt", NULL
21010 };
21011
21012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21014 if (!SWIG_IsOK(res1)) {
21015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21016 }
21017 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21018 if (obj1) {
21019 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21020 if (!SWIG_IsOK(ecode2)) {
21021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21022 }
21023 arg2 = static_cast< bool >(val2);
21024 }
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 (arg1)->SetRecordDefaults(arg2);
21028 wxPyEndAllowThreads(__tstate);
21029 if (PyErr_Occurred()) SWIG_fail;
21030 }
21031 resultobj = SWIG_Py_Void();
21032 return resultobj;
21033 fail:
21034 return NULL;
21035 }
21036
21037
21038 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21039 PyObject *resultobj = 0;
21040 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21041 bool result;
21042 void *argp1 = 0 ;
21043 int res1 = 0 ;
21044 PyObject *swig_obj[1] ;
21045
21046 if (!args) SWIG_fail;
21047 swig_obj[0] = args;
21048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21049 if (!SWIG_IsOK(res1)) {
21050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21051 }
21052 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21053 {
21054 PyThreadState* __tstate = wxPyBeginAllowThreads();
21055 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 {
21060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21061 }
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj = 0;
21070 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21071 wxString *arg2 = 0 ;
21072 wxString result;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 bool temp2 = false ;
21076 PyObject * obj0 = 0 ;
21077 PyObject * obj1 = 0 ;
21078 char * kwnames[] = {
21079 (char *) "self",(char *) "str", NULL
21080 };
21081
21082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21086 }
21087 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21088 {
21089 arg2 = wxString_in_helper(obj1);
21090 if (arg2 == NULL) SWIG_fail;
21091 temp2 = true;
21092 }
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 {
21100 #if wxUSE_UNICODE
21101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21102 #else
21103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21104 #endif
21105 }
21106 {
21107 if (temp2)
21108 delete arg2;
21109 }
21110 return resultobj;
21111 fail:
21112 {
21113 if (temp2)
21114 delete arg2;
21115 }
21116 return NULL;
21117 }
21118
21119
21120 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21121 PyObject *resultobj = 0;
21122 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21123 wxString result;
21124 void *argp1 = 0 ;
21125 int res1 = 0 ;
21126 PyObject *swig_obj[1] ;
21127
21128 if (!args) SWIG_fail;
21129 swig_obj[0] = args;
21130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21131 if (!SWIG_IsOK(res1)) {
21132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21133 }
21134 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = ((wxConfigBase const *)arg1)->GetAppName();
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 {
21142 #if wxUSE_UNICODE
21143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21144 #else
21145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21146 #endif
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *resultobj = 0;
21156 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21157 wxString result;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 PyObject *swig_obj[1] ;
21161
21162 if (!args) SWIG_fail;
21163 swig_obj[0] = args;
21164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21165 if (!SWIG_IsOK(res1)) {
21166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21167 }
21168 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = ((wxConfigBase const *)arg1)->GetVendorName();
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 {
21176 #if wxUSE_UNICODE
21177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21178 #else
21179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21180 #endif
21181 }
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj = 0;
21190 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21191 wxString *arg2 = 0 ;
21192 void *argp1 = 0 ;
21193 int res1 = 0 ;
21194 bool temp2 = false ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 char * kwnames[] = {
21198 (char *) "self",(char *) "appName", NULL
21199 };
21200
21201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21205 }
21206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21207 {
21208 arg2 = wxString_in_helper(obj1);
21209 if (arg2 == NULL) SWIG_fail;
21210 temp2 = true;
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 (arg1)->SetAppName((wxString const &)*arg2);
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 resultobj = SWIG_Py_Void();
21219 {
21220 if (temp2)
21221 delete arg2;
21222 }
21223 return resultobj;
21224 fail:
21225 {
21226 if (temp2)
21227 delete arg2;
21228 }
21229 return NULL;
21230 }
21231
21232
21233 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21234 PyObject *resultobj = 0;
21235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21236 wxString *arg2 = 0 ;
21237 void *argp1 = 0 ;
21238 int res1 = 0 ;
21239 bool temp2 = false ;
21240 PyObject * obj0 = 0 ;
21241 PyObject * obj1 = 0 ;
21242 char * kwnames[] = {
21243 (char *) "self",(char *) "vendorName", NULL
21244 };
21245
21246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21248 if (!SWIG_IsOK(res1)) {
21249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21250 }
21251 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21252 {
21253 arg2 = wxString_in_helper(obj1);
21254 if (arg2 == NULL) SWIG_fail;
21255 temp2 = true;
21256 }
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 (arg1)->SetVendorName((wxString const &)*arg2);
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 resultobj = SWIG_Py_Void();
21264 {
21265 if (temp2)
21266 delete arg2;
21267 }
21268 return resultobj;
21269 fail:
21270 {
21271 if (temp2)
21272 delete arg2;
21273 }
21274 return NULL;
21275 }
21276
21277
21278 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj = 0;
21280 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21281 long arg2 ;
21282 void *argp1 = 0 ;
21283 int res1 = 0 ;
21284 long val2 ;
21285 int ecode2 = 0 ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char * kwnames[] = {
21289 (char *) "self",(char *) "style", NULL
21290 };
21291
21292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21296 }
21297 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21298 ecode2 = SWIG_AsVal_long(obj1, &val2);
21299 if (!SWIG_IsOK(ecode2)) {
21300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21301 }
21302 arg2 = static_cast< long >(val2);
21303 {
21304 PyThreadState* __tstate = wxPyBeginAllowThreads();
21305 (arg1)->SetStyle(arg2);
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 resultobj = SWIG_Py_Void();
21310 return resultobj;
21311 fail:
21312 return NULL;
21313 }
21314
21315
21316 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21317 PyObject *resultobj = 0;
21318 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21319 long result;
21320 void *argp1 = 0 ;
21321 int res1 = 0 ;
21322 PyObject *swig_obj[1] ;
21323
21324 if (!args) SWIG_fail;
21325 swig_obj[0] = args;
21326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21327 if (!SWIG_IsOK(res1)) {
21328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21329 }
21330 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21334 wxPyEndAllowThreads(__tstate);
21335 if (PyErr_Occurred()) SWIG_fail;
21336 }
21337 resultobj = SWIG_From_long(static_cast< long >(result));
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21345 PyObject *obj;
21346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21347 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21348 return SWIG_Py_Void();
21349 }
21350
21351 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21352 PyObject *resultobj = 0;
21353 wxString const &arg1_defvalue = wxPyEmptyString ;
21354 wxString *arg1 = (wxString *) &arg1_defvalue ;
21355 wxString const &arg2_defvalue = wxPyEmptyString ;
21356 wxString *arg2 = (wxString *) &arg2_defvalue ;
21357 wxString const &arg3_defvalue = wxPyEmptyString ;
21358 wxString *arg3 = (wxString *) &arg3_defvalue ;
21359 wxString const &arg4_defvalue = wxPyEmptyString ;
21360 wxString *arg4 = (wxString *) &arg4_defvalue ;
21361 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21362 wxConfig *result = 0 ;
21363 bool temp1 = false ;
21364 bool temp2 = false ;
21365 bool temp3 = false ;
21366 bool temp4 = false ;
21367 long val5 ;
21368 int ecode5 = 0 ;
21369 PyObject * obj0 = 0 ;
21370 PyObject * obj1 = 0 ;
21371 PyObject * obj2 = 0 ;
21372 PyObject * obj3 = 0 ;
21373 PyObject * obj4 = 0 ;
21374 char * kwnames[] = {
21375 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21376 };
21377
21378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21379 if (obj0) {
21380 {
21381 arg1 = wxString_in_helper(obj0);
21382 if (arg1 == NULL) SWIG_fail;
21383 temp1 = true;
21384 }
21385 }
21386 if (obj1) {
21387 {
21388 arg2 = wxString_in_helper(obj1);
21389 if (arg2 == NULL) SWIG_fail;
21390 temp2 = true;
21391 }
21392 }
21393 if (obj2) {
21394 {
21395 arg3 = wxString_in_helper(obj2);
21396 if (arg3 == NULL) SWIG_fail;
21397 temp3 = true;
21398 }
21399 }
21400 if (obj3) {
21401 {
21402 arg4 = wxString_in_helper(obj3);
21403 if (arg4 == NULL) SWIG_fail;
21404 temp4 = true;
21405 }
21406 }
21407 if (obj4) {
21408 ecode5 = SWIG_AsVal_long(obj4, &val5);
21409 if (!SWIG_IsOK(ecode5)) {
21410 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21411 }
21412 arg5 = static_cast< long >(val5);
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21421 {
21422 if (temp1)
21423 delete arg1;
21424 }
21425 {
21426 if (temp2)
21427 delete arg2;
21428 }
21429 {
21430 if (temp3)
21431 delete arg3;
21432 }
21433 {
21434 if (temp4)
21435 delete arg4;
21436 }
21437 return resultobj;
21438 fail:
21439 {
21440 if (temp1)
21441 delete arg1;
21442 }
21443 {
21444 if (temp2)
21445 delete arg2;
21446 }
21447 {
21448 if (temp3)
21449 delete arg3;
21450 }
21451 {
21452 if (temp4)
21453 delete arg4;
21454 }
21455 return NULL;
21456 }
21457
21458
21459 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21460 PyObject *resultobj = 0;
21461 wxConfig *arg1 = (wxConfig *) 0 ;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 PyObject *swig_obj[1] ;
21465
21466 if (!args) SWIG_fail;
21467 swig_obj[0] = args;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21471 }
21472 arg1 = reinterpret_cast< wxConfig * >(argp1);
21473 {
21474 PyThreadState* __tstate = wxPyBeginAllowThreads();
21475 delete arg1;
21476
21477 wxPyEndAllowThreads(__tstate);
21478 if (PyErr_Occurred()) SWIG_fail;
21479 }
21480 resultobj = SWIG_Py_Void();
21481 return resultobj;
21482 fail:
21483 return NULL;
21484 }
21485
21486
21487 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21488 PyObject *obj;
21489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21490 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21491 return SWIG_Py_Void();
21492 }
21493
21494 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 return SWIG_Python_InitShadowInstance(args);
21496 }
21497
21498 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21499 PyObject *resultobj = 0;
21500 wxString const &arg1_defvalue = wxPyEmptyString ;
21501 wxString *arg1 = (wxString *) &arg1_defvalue ;
21502 wxString const &arg2_defvalue = wxPyEmptyString ;
21503 wxString *arg2 = (wxString *) &arg2_defvalue ;
21504 wxString const &arg3_defvalue = wxPyEmptyString ;
21505 wxString *arg3 = (wxString *) &arg3_defvalue ;
21506 wxString const &arg4_defvalue = wxPyEmptyString ;
21507 wxString *arg4 = (wxString *) &arg4_defvalue ;
21508 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21509 wxFileConfig *result = 0 ;
21510 bool temp1 = false ;
21511 bool temp2 = false ;
21512 bool temp3 = false ;
21513 bool temp4 = false ;
21514 long val5 ;
21515 int ecode5 = 0 ;
21516 PyObject * obj0 = 0 ;
21517 PyObject * obj1 = 0 ;
21518 PyObject * obj2 = 0 ;
21519 PyObject * obj3 = 0 ;
21520 PyObject * obj4 = 0 ;
21521 char * kwnames[] = {
21522 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21523 };
21524
21525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21526 if (obj0) {
21527 {
21528 arg1 = wxString_in_helper(obj0);
21529 if (arg1 == NULL) SWIG_fail;
21530 temp1 = true;
21531 }
21532 }
21533 if (obj1) {
21534 {
21535 arg2 = wxString_in_helper(obj1);
21536 if (arg2 == NULL) SWIG_fail;
21537 temp2 = true;
21538 }
21539 }
21540 if (obj2) {
21541 {
21542 arg3 = wxString_in_helper(obj2);
21543 if (arg3 == NULL) SWIG_fail;
21544 temp3 = true;
21545 }
21546 }
21547 if (obj3) {
21548 {
21549 arg4 = wxString_in_helper(obj3);
21550 if (arg4 == NULL) SWIG_fail;
21551 temp4 = true;
21552 }
21553 }
21554 if (obj4) {
21555 ecode5 = SWIG_AsVal_long(obj4, &val5);
21556 if (!SWIG_IsOK(ecode5)) {
21557 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21558 }
21559 arg5 = static_cast< long >(val5);
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21568 {
21569 if (temp1)
21570 delete arg1;
21571 }
21572 {
21573 if (temp2)
21574 delete arg2;
21575 }
21576 {
21577 if (temp3)
21578 delete arg3;
21579 }
21580 {
21581 if (temp4)
21582 delete arg4;
21583 }
21584 return resultobj;
21585 fail:
21586 {
21587 if (temp1)
21588 delete arg1;
21589 }
21590 {
21591 if (temp2)
21592 delete arg2;
21593 }
21594 {
21595 if (temp3)
21596 delete arg3;
21597 }
21598 {
21599 if (temp4)
21600 delete arg4;
21601 }
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *resultobj = 0;
21608 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 PyObject *swig_obj[1] ;
21612
21613 if (!args) SWIG_fail;
21614 swig_obj[0] = args;
21615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21616 if (!SWIG_IsOK(res1)) {
21617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21618 }
21619 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21620 {
21621 PyThreadState* __tstate = wxPyBeginAllowThreads();
21622 delete arg1;
21623
21624 wxPyEndAllowThreads(__tstate);
21625 if (PyErr_Occurred()) SWIG_fail;
21626 }
21627 resultobj = SWIG_Py_Void();
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21635 PyObject *obj;
21636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21637 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21638 return SWIG_Py_Void();
21639 }
21640
21641 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 return SWIG_Python_InitShadowInstance(args);
21643 }
21644
21645 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21646 PyObject *resultobj = 0;
21647 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21648 wxString *arg2 = 0 ;
21649 wxConfigPathChanger *result = 0 ;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 bool temp2 = false ;
21653 PyObject * obj0 = 0 ;
21654 PyObject * obj1 = 0 ;
21655 char * kwnames[] = {
21656 (char *) "config",(char *) "entry", NULL
21657 };
21658
21659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21663 }
21664 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21665 {
21666 arg2 = wxString_in_helper(obj1);
21667 if (arg2 == NULL) SWIG_fail;
21668 temp2 = true;
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21677 {
21678 if (temp2)
21679 delete arg2;
21680 }
21681 return resultobj;
21682 fail:
21683 {
21684 if (temp2)
21685 delete arg2;
21686 }
21687 return NULL;
21688 }
21689
21690
21691 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21692 PyObject *resultobj = 0;
21693 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21694 void *argp1 = 0 ;
21695 int res1 = 0 ;
21696 PyObject *swig_obj[1] ;
21697
21698 if (!args) SWIG_fail;
21699 swig_obj[0] = args;
21700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21701 if (!SWIG_IsOK(res1)) {
21702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21703 }
21704 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21705 {
21706 PyThreadState* __tstate = wxPyBeginAllowThreads();
21707 delete arg1;
21708
21709 wxPyEndAllowThreads(__tstate);
21710 if (PyErr_Occurred()) SWIG_fail;
21711 }
21712 resultobj = SWIG_Py_Void();
21713 return resultobj;
21714 fail:
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21720 PyObject *resultobj = 0;
21721 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21722 wxString *result = 0 ;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21732 }
21733 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 {
21737 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21738 result = (wxString *) &_result_ref;
21739 }
21740 wxPyEndAllowThreads(__tstate);
21741 if (PyErr_Occurred()) SWIG_fail;
21742 }
21743 {
21744 #if wxUSE_UNICODE
21745 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21746 #else
21747 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21748 #endif
21749 }
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *obj;
21758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21759 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21760 return SWIG_Py_Void();
21761 }
21762
21763 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21764 return SWIG_Python_InitShadowInstance(args);
21765 }
21766
21767 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21768 PyObject *resultobj = 0;
21769 wxString *arg1 = 0 ;
21770 wxString result;
21771 bool temp1 = false ;
21772 PyObject * obj0 = 0 ;
21773 char * kwnames[] = {
21774 (char *) "sz", NULL
21775 };
21776
21777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21778 {
21779 arg1 = wxString_in_helper(obj0);
21780 if (arg1 == NULL) SWIG_fail;
21781 temp1 = true;
21782 }
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = wxExpandEnvVars((wxString const &)*arg1);
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 {
21790 #if wxUSE_UNICODE
21791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21792 #else
21793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21794 #endif
21795 }
21796 {
21797 if (temp1)
21798 delete arg1;
21799 }
21800 return resultobj;
21801 fail:
21802 {
21803 if (temp1)
21804 delete arg1;
21805 }
21806 return NULL;
21807 }
21808
21809
21810 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21811 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21812 return 1;
21813 }
21814
21815
21816 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21817 PyObject *pyobj = 0;
21818
21819 {
21820 #if wxUSE_UNICODE
21821 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21822 #else
21823 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21824 #endif
21825 }
21826 return pyobj;
21827 }
21828
21829
21830 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21831 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21832 return 1;
21833 }
21834
21835
21836 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21837 PyObject *pyobj = 0;
21838
21839 {
21840 #if wxUSE_UNICODE
21841 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21842 #else
21843 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21844 #endif
21845 }
21846 return pyobj;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21851 PyObject *resultobj = 0;
21852 wxDateTime::Country arg1 ;
21853 int val1 ;
21854 int ecode1 = 0 ;
21855 PyObject * obj0 = 0 ;
21856 char * kwnames[] = {
21857 (char *) "country", NULL
21858 };
21859
21860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21861 ecode1 = SWIG_AsVal_int(obj0, &val1);
21862 if (!SWIG_IsOK(ecode1)) {
21863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21864 }
21865 arg1 = static_cast< wxDateTime::Country >(val1);
21866 {
21867 PyThreadState* __tstate = wxPyBeginAllowThreads();
21868 wxDateTime::SetCountry(arg1);
21869 wxPyEndAllowThreads(__tstate);
21870 if (PyErr_Occurred()) SWIG_fail;
21871 }
21872 resultobj = SWIG_Py_Void();
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21880 PyObject *resultobj = 0;
21881 wxDateTime::Country result;
21882
21883 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (wxDateTime::Country)wxDateTime::GetCountry();
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 resultobj = SWIG_From_int(static_cast< int >(result));
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj = 0;
21899 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21900 bool result;
21901 int val1 ;
21902 int ecode1 = 0 ;
21903 PyObject * obj0 = 0 ;
21904 char * kwnames[] = {
21905 (char *) "country", NULL
21906 };
21907
21908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21909 if (obj0) {
21910 ecode1 = SWIG_AsVal_int(obj0, &val1);
21911 if (!SWIG_IsOK(ecode1)) {
21912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21913 }
21914 arg1 = static_cast< wxDateTime::Country >(val1);
21915 }
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21924 }
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj = 0;
21933 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21934 int result;
21935 int val1 ;
21936 int ecode1 = 0 ;
21937 PyObject * obj0 = 0 ;
21938 char * kwnames[] = {
21939 (char *) "cal", NULL
21940 };
21941
21942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21943 if (obj0) {
21944 ecode1 = SWIG_AsVal_int(obj0, &val1);
21945 if (!SWIG_IsOK(ecode1)) {
21946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21947 }
21948 arg1 = static_cast< wxDateTime::Calendar >(val1);
21949 }
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 result = (int)wxDateTime::GetCurrentYear(arg1);
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 resultobj = SWIG_From_int(static_cast< int >(result));
21957 return resultobj;
21958 fail:
21959 return NULL;
21960 }
21961
21962
21963 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj = 0;
21965 int arg1 ;
21966 int result;
21967 int val1 ;
21968 int ecode1 = 0 ;
21969 PyObject * obj0 = 0 ;
21970 char * kwnames[] = {
21971 (char *) "year", NULL
21972 };
21973
21974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21975 ecode1 = SWIG_AsVal_int(obj0, &val1);
21976 if (!SWIG_IsOK(ecode1)) {
21977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21978 }
21979 arg1 = static_cast< int >(val1);
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 result = (int)wxDateTime::ConvertYearToBC(arg1);
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_From_int(static_cast< int >(result));
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21994 PyObject *resultobj = 0;
21995 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21996 wxDateTime::Month result;
21997 int val1 ;
21998 int ecode1 = 0 ;
21999 PyObject * obj0 = 0 ;
22000 char * kwnames[] = {
22001 (char *) "cal", NULL
22002 };
22003
22004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22005 if (obj0) {
22006 ecode1 = SWIG_AsVal_int(obj0, &val1);
22007 if (!SWIG_IsOK(ecode1)) {
22008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22009 }
22010 arg1 = static_cast< wxDateTime::Calendar >(val1);
22011 }
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22015 wxPyEndAllowThreads(__tstate);
22016 if (PyErr_Occurred()) SWIG_fail;
22017 }
22018 resultobj = SWIG_From_int(static_cast< int >(result));
22019 return resultobj;
22020 fail:
22021 return NULL;
22022 }
22023
22024
22025 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj = 0;
22027 int arg1 = (int) wxDateTime::Inv_Year ;
22028 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22029 bool result;
22030 int val1 ;
22031 int ecode1 = 0 ;
22032 int val2 ;
22033 int ecode2 = 0 ;
22034 PyObject * obj0 = 0 ;
22035 PyObject * obj1 = 0 ;
22036 char * kwnames[] = {
22037 (char *) "year",(char *) "cal", NULL
22038 };
22039
22040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22041 if (obj0) {
22042 ecode1 = SWIG_AsVal_int(obj0, &val1);
22043 if (!SWIG_IsOK(ecode1)) {
22044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22045 }
22046 arg1 = static_cast< int >(val1);
22047 }
22048 if (obj1) {
22049 ecode2 = SWIG_AsVal_int(obj1, &val2);
22050 if (!SWIG_IsOK(ecode2)) {
22051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22052 }
22053 arg2 = static_cast< wxDateTime::Calendar >(val2);
22054 }
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 {
22062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22063 }
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22071 PyObject *resultobj = 0;
22072 int arg1 = (int) wxDateTime::Inv_Year ;
22073 int result;
22074 int val1 ;
22075 int ecode1 = 0 ;
22076 PyObject * obj0 = 0 ;
22077 char * kwnames[] = {
22078 (char *) "year", NULL
22079 };
22080
22081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22082 if (obj0) {
22083 ecode1 = SWIG_AsVal_int(obj0, &val1);
22084 if (!SWIG_IsOK(ecode1)) {
22085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22086 }
22087 arg1 = static_cast< int >(val1);
22088 }
22089 {
22090 PyThreadState* __tstate = wxPyBeginAllowThreads();
22091 result = (int)wxDateTime::GetCentury(arg1);
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 resultobj = SWIG_From_int(static_cast< int >(result));
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj = 0;
22104 int arg1 ;
22105 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22106 int result;
22107 int val1 ;
22108 int ecode1 = 0 ;
22109 int val2 ;
22110 int ecode2 = 0 ;
22111 PyObject * obj0 = 0 ;
22112 PyObject * obj1 = 0 ;
22113 char * kwnames[] = {
22114 (char *) "year",(char *) "cal", NULL
22115 };
22116
22117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22118 ecode1 = SWIG_AsVal_int(obj0, &val1);
22119 if (!SWIG_IsOK(ecode1)) {
22120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22121 }
22122 arg1 = static_cast< int >(val1);
22123 if (obj1) {
22124 ecode2 = SWIG_AsVal_int(obj1, &val2);
22125 if (!SWIG_IsOK(ecode2)) {
22126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22127 }
22128 arg2 = static_cast< wxDateTime::Calendar >(val2);
22129 }
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 resultobj = SWIG_From_int(static_cast< int >(result));
22137 return resultobj;
22138 fail:
22139 return NULL;
22140 }
22141
22142
22143 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22144 PyObject *resultobj = 0;
22145 wxDateTime::Month arg1 ;
22146 int arg2 = (int) wxDateTime::Inv_Year ;
22147 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22148 int result;
22149 int val1 ;
22150 int ecode1 = 0 ;
22151 int val2 ;
22152 int ecode2 = 0 ;
22153 int val3 ;
22154 int ecode3 = 0 ;
22155 PyObject * obj0 = 0 ;
22156 PyObject * obj1 = 0 ;
22157 PyObject * obj2 = 0 ;
22158 char * kwnames[] = {
22159 (char *) "month",(char *) "year",(char *) "cal", NULL
22160 };
22161
22162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22163 ecode1 = SWIG_AsVal_int(obj0, &val1);
22164 if (!SWIG_IsOK(ecode1)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22166 }
22167 arg1 = static_cast< wxDateTime::Month >(val1);
22168 if (obj1) {
22169 ecode2 = SWIG_AsVal_int(obj1, &val2);
22170 if (!SWIG_IsOK(ecode2)) {
22171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22172 }
22173 arg2 = static_cast< int >(val2);
22174 }
22175 if (obj2) {
22176 ecode3 = SWIG_AsVal_int(obj2, &val3);
22177 if (!SWIG_IsOK(ecode3)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22179 }
22180 arg3 = static_cast< wxDateTime::Calendar >(val3);
22181 }
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_From_int(static_cast< int >(result));
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj = 0;
22197 wxDateTime::Month arg1 ;
22198 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22199 wxString result;
22200 int val1 ;
22201 int ecode1 = 0 ;
22202 int val2 ;
22203 int ecode2 = 0 ;
22204 PyObject * obj0 = 0 ;
22205 PyObject * obj1 = 0 ;
22206 char * kwnames[] = {
22207 (char *) "month",(char *) "flags", NULL
22208 };
22209
22210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22211 ecode1 = SWIG_AsVal_int(obj0, &val1);
22212 if (!SWIG_IsOK(ecode1)) {
22213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22214 }
22215 arg1 = static_cast< wxDateTime::Month >(val1);
22216 if (obj1) {
22217 ecode2 = SWIG_AsVal_int(obj1, &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22220 }
22221 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22222 }
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = wxDateTime::GetMonthName(arg1,arg2);
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 {
22230 #if wxUSE_UNICODE
22231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22232 #else
22233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22234 #endif
22235 }
22236 return resultobj;
22237 fail:
22238 return NULL;
22239 }
22240
22241
22242 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22243 PyObject *resultobj = 0;
22244 wxDateTime::WeekDay arg1 ;
22245 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22246 wxString result;
22247 int val1 ;
22248 int ecode1 = 0 ;
22249 int val2 ;
22250 int ecode2 = 0 ;
22251 PyObject * obj0 = 0 ;
22252 PyObject * obj1 = 0 ;
22253 char * kwnames[] = {
22254 (char *) "weekday",(char *) "flags", NULL
22255 };
22256
22257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22258 ecode1 = SWIG_AsVal_int(obj0, &val1);
22259 if (!SWIG_IsOK(ecode1)) {
22260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22261 }
22262 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22263 if (obj1) {
22264 ecode2 = SWIG_AsVal_int(obj1, &val2);
22265 if (!SWIG_IsOK(ecode2)) {
22266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22267 }
22268 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22269 }
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 result = wxDateTime::GetWeekDayName(arg1,arg2);
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 {
22277 #if wxUSE_UNICODE
22278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22279 #else
22280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22281 #endif
22282 }
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 PyObject *resultobj = 0;
22291 PyObject *result = 0 ;
22292
22293 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (PyObject *)wxDateTime_GetAmPmStrings();
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 resultobj = result;
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22308 PyObject *resultobj = 0;
22309 int arg1 = (int) wxDateTime::Inv_Year ;
22310 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22311 bool result;
22312 int val1 ;
22313 int ecode1 = 0 ;
22314 int val2 ;
22315 int ecode2 = 0 ;
22316 PyObject * obj0 = 0 ;
22317 PyObject * obj1 = 0 ;
22318 char * kwnames[] = {
22319 (char *) "year",(char *) "country", NULL
22320 };
22321
22322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22323 if (obj0) {
22324 ecode1 = SWIG_AsVal_int(obj0, &val1);
22325 if (!SWIG_IsOK(ecode1)) {
22326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22327 }
22328 arg1 = static_cast< int >(val1);
22329 }
22330 if (obj1) {
22331 ecode2 = SWIG_AsVal_int(obj1, &val2);
22332 if (!SWIG_IsOK(ecode2)) {
22333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22334 }
22335 arg2 = static_cast< wxDateTime::Country >(val2);
22336 }
22337 {
22338 PyThreadState* __tstate = wxPyBeginAllowThreads();
22339 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22345 }
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj = 0;
22354 int arg1 = (int) wxDateTime::Inv_Year ;
22355 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22356 wxDateTime result;
22357 int val1 ;
22358 int ecode1 = 0 ;
22359 int val2 ;
22360 int ecode2 = 0 ;
22361 PyObject * obj0 = 0 ;
22362 PyObject * obj1 = 0 ;
22363 char * kwnames[] = {
22364 (char *) "year",(char *) "country", NULL
22365 };
22366
22367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22368 if (obj0) {
22369 ecode1 = SWIG_AsVal_int(obj0, &val1);
22370 if (!SWIG_IsOK(ecode1)) {
22371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22372 }
22373 arg1 = static_cast< int >(val1);
22374 }
22375 if (obj1) {
22376 ecode2 = SWIG_AsVal_int(obj1, &val2);
22377 if (!SWIG_IsOK(ecode2)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22379 }
22380 arg2 = static_cast< wxDateTime::Country >(val2);
22381 }
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = wxDateTime::GetBeginDST(arg1,arg2);
22385 wxPyEndAllowThreads(__tstate);
22386 if (PyErr_Occurred()) SWIG_fail;
22387 }
22388 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22396 PyObject *resultobj = 0;
22397 int arg1 = (int) wxDateTime::Inv_Year ;
22398 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22399 wxDateTime result;
22400 int val1 ;
22401 int ecode1 = 0 ;
22402 int val2 ;
22403 int ecode2 = 0 ;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char * kwnames[] = {
22407 (char *) "year",(char *) "country", NULL
22408 };
22409
22410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22411 if (obj0) {
22412 ecode1 = SWIG_AsVal_int(obj0, &val1);
22413 if (!SWIG_IsOK(ecode1)) {
22414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22415 }
22416 arg1 = static_cast< int >(val1);
22417 }
22418 if (obj1) {
22419 ecode2 = SWIG_AsVal_int(obj1, &val2);
22420 if (!SWIG_IsOK(ecode2)) {
22421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22422 }
22423 arg2 = static_cast< wxDateTime::Country >(val2);
22424 }
22425 {
22426 PyThreadState* __tstate = wxPyBeginAllowThreads();
22427 result = wxDateTime::GetEndDST(arg1,arg2);
22428 wxPyEndAllowThreads(__tstate);
22429 if (PyErr_Occurred()) SWIG_fail;
22430 }
22431 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22439 PyObject *resultobj = 0;
22440 wxDateTime result;
22441
22442 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 result = wxDateTime::Now();
22446 wxPyEndAllowThreads(__tstate);
22447 if (PyErr_Occurred()) SWIG_fail;
22448 }
22449 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxDateTime result;
22459
22460 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 result = wxDateTime::UNow();
22464 wxPyEndAllowThreads(__tstate);
22465 if (PyErr_Occurred()) SWIG_fail;
22466 }
22467 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22475 PyObject *resultobj = 0;
22476 wxDateTime result;
22477
22478 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22479 {
22480 PyThreadState* __tstate = wxPyBeginAllowThreads();
22481 result = wxDateTime::Today();
22482 wxPyEndAllowThreads(__tstate);
22483 if (PyErr_Occurred()) SWIG_fail;
22484 }
22485 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22493 PyObject *resultobj = 0;
22494 wxDateTime *result = 0 ;
22495
22496 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 result = (wxDateTime *)new wxDateTime();
22500 wxPyEndAllowThreads(__tstate);
22501 if (PyErr_Occurred()) SWIG_fail;
22502 }
22503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22511 PyObject *resultobj = 0;
22512 time_t arg1 ;
22513 wxDateTime *result = 0 ;
22514 unsigned int val1 ;
22515 int ecode1 = 0 ;
22516 PyObject * obj0 = 0 ;
22517 char * kwnames[] = {
22518 (char *) "timet", NULL
22519 };
22520
22521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22522 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22523 if (!SWIG_IsOK(ecode1)) {
22524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22525 }
22526 arg1 = static_cast< time_t >(val1);
22527 {
22528 PyThreadState* __tstate = wxPyBeginAllowThreads();
22529 result = (wxDateTime *)new wxDateTime(arg1);
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj = 0;
22542 double arg1 ;
22543 wxDateTime *result = 0 ;
22544 double val1 ;
22545 int ecode1 = 0 ;
22546 PyObject * obj0 = 0 ;
22547 char * kwnames[] = {
22548 (char *) "jdn", NULL
22549 };
22550
22551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22552 ecode1 = SWIG_AsVal_double(obj0, &val1);
22553 if (!SWIG_IsOK(ecode1)) {
22554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22555 }
22556 arg1 = static_cast< double >(val1);
22557 {
22558 PyThreadState* __tstate = wxPyBeginAllowThreads();
22559 result = (wxDateTime *)new wxDateTime(arg1);
22560 wxPyEndAllowThreads(__tstate);
22561 if (PyErr_Occurred()) SWIG_fail;
22562 }
22563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = 0;
22572 int arg1 ;
22573 int arg2 = (int) 0 ;
22574 int arg3 = (int) 0 ;
22575 int arg4 = (int) 0 ;
22576 wxDateTime *result = 0 ;
22577 int val1 ;
22578 int ecode1 = 0 ;
22579 int val2 ;
22580 int ecode2 = 0 ;
22581 int val3 ;
22582 int ecode3 = 0 ;
22583 int val4 ;
22584 int ecode4 = 0 ;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 PyObject * obj2 = 0 ;
22588 PyObject * obj3 = 0 ;
22589 char * kwnames[] = {
22590 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22591 };
22592
22593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22594 ecode1 = SWIG_AsVal_int(obj0, &val1);
22595 if (!SWIG_IsOK(ecode1)) {
22596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22597 }
22598 arg1 = static_cast< int >(val1);
22599 if (obj1) {
22600 ecode2 = SWIG_AsVal_int(obj1, &val2);
22601 if (!SWIG_IsOK(ecode2)) {
22602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22603 }
22604 arg2 = static_cast< int >(val2);
22605 }
22606 if (obj2) {
22607 ecode3 = SWIG_AsVal_int(obj2, &val3);
22608 if (!SWIG_IsOK(ecode3)) {
22609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22610 }
22611 arg3 = static_cast< int >(val3);
22612 }
22613 if (obj3) {
22614 ecode4 = SWIG_AsVal_int(obj3, &val4);
22615 if (!SWIG_IsOK(ecode4)) {
22616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22617 }
22618 arg4 = static_cast< int >(val4);
22619 }
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj = 0;
22635 int arg1 ;
22636 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22637 int arg3 = (int) wxDateTime::Inv_Year ;
22638 int arg4 = (int) 0 ;
22639 int arg5 = (int) 0 ;
22640 int arg6 = (int) 0 ;
22641 int arg7 = (int) 0 ;
22642 wxDateTime *result = 0 ;
22643 int val1 ;
22644 int ecode1 = 0 ;
22645 int val2 ;
22646 int ecode2 = 0 ;
22647 int val3 ;
22648 int ecode3 = 0 ;
22649 int val4 ;
22650 int ecode4 = 0 ;
22651 int val5 ;
22652 int ecode5 = 0 ;
22653 int val6 ;
22654 int ecode6 = 0 ;
22655 int val7 ;
22656 int ecode7 = 0 ;
22657 PyObject * obj0 = 0 ;
22658 PyObject * obj1 = 0 ;
22659 PyObject * obj2 = 0 ;
22660 PyObject * obj3 = 0 ;
22661 PyObject * obj4 = 0 ;
22662 PyObject * obj5 = 0 ;
22663 PyObject * obj6 = 0 ;
22664 char * kwnames[] = {
22665 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22666 };
22667
22668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22669 ecode1 = SWIG_AsVal_int(obj0, &val1);
22670 if (!SWIG_IsOK(ecode1)) {
22671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22672 }
22673 arg1 = static_cast< int >(val1);
22674 if (obj1) {
22675 ecode2 = SWIG_AsVal_int(obj1, &val2);
22676 if (!SWIG_IsOK(ecode2)) {
22677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22678 }
22679 arg2 = static_cast< wxDateTime::Month >(val2);
22680 }
22681 if (obj2) {
22682 ecode3 = SWIG_AsVal_int(obj2, &val3);
22683 if (!SWIG_IsOK(ecode3)) {
22684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22685 }
22686 arg3 = static_cast< int >(val3);
22687 }
22688 if (obj3) {
22689 ecode4 = SWIG_AsVal_int(obj3, &val4);
22690 if (!SWIG_IsOK(ecode4)) {
22691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22692 }
22693 arg4 = static_cast< int >(val4);
22694 }
22695 if (obj4) {
22696 ecode5 = SWIG_AsVal_int(obj4, &val5);
22697 if (!SWIG_IsOK(ecode5)) {
22698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22699 }
22700 arg5 = static_cast< int >(val5);
22701 }
22702 if (obj5) {
22703 ecode6 = SWIG_AsVal_int(obj5, &val6);
22704 if (!SWIG_IsOK(ecode6)) {
22705 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22706 }
22707 arg6 = static_cast< int >(val6);
22708 }
22709 if (obj6) {
22710 ecode7 = SWIG_AsVal_int(obj6, &val7);
22711 if (!SWIG_IsOK(ecode7)) {
22712 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22713 }
22714 arg7 = static_cast< int >(val7);
22715 }
22716 {
22717 PyThreadState* __tstate = wxPyBeginAllowThreads();
22718 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22719 wxPyEndAllowThreads(__tstate);
22720 if (PyErr_Occurred()) SWIG_fail;
22721 }
22722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22730 PyObject *resultobj = 0;
22731 wxDateTime *arg1 = 0 ;
22732 wxDateTime *result = 0 ;
22733 void *argp1 = 0 ;
22734 int res1 = 0 ;
22735 PyObject * obj0 = 0 ;
22736 char * kwnames[] = {
22737 (char *) "date", NULL
22738 };
22739
22740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22741 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22742 if (!SWIG_IsOK(res1)) {
22743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22744 }
22745 if (!argp1) {
22746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22747 }
22748 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22752 wxPyEndAllowThreads(__tstate);
22753 if (PyErr_Occurred()) SWIG_fail;
22754 }
22755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22756 return resultobj;
22757 fail:
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxDateTime *arg1 = (wxDateTime *) 0 ;
22765 void *argp1 = 0 ;
22766 int res1 = 0 ;
22767 PyObject *swig_obj[1] ;
22768
22769 if (!args) SWIG_fail;
22770 swig_obj[0] = args;
22771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22772 if (!SWIG_IsOK(res1)) {
22773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22774 }
22775 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 delete arg1;
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 resultobj = SWIG_Py_Void();
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxDateTime *arg1 = (wxDateTime *) 0 ;
22793 wxDateTime *result = 0 ;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 PyObject *swig_obj[1] ;
22797
22798 if (!args) SWIG_fail;
22799 swig_obj[0] = args;
22800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22801 if (!SWIG_IsOK(res1)) {
22802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22803 }
22804 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 {
22808 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22809 result = (wxDateTime *) &_result_ref;
22810 }
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj = 0;
22823 wxDateTime *arg1 = (wxDateTime *) 0 ;
22824 time_t arg2 ;
22825 wxDateTime *result = 0 ;
22826 void *argp1 = 0 ;
22827 int res1 = 0 ;
22828 unsigned int val2 ;
22829 int ecode2 = 0 ;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832 char * kwnames[] = {
22833 (char *) "self",(char *) "timet", NULL
22834 };
22835
22836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22840 }
22841 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22842 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22843 if (!SWIG_IsOK(ecode2)) {
22844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22845 }
22846 arg2 = static_cast< time_t >(val2);
22847 {
22848 PyThreadState* __tstate = wxPyBeginAllowThreads();
22849 {
22850 wxDateTime &_result_ref = (arg1)->Set(arg2);
22851 result = (wxDateTime *) &_result_ref;
22852 }
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22864 PyObject *resultobj = 0;
22865 wxDateTime *arg1 = (wxDateTime *) 0 ;
22866 double arg2 ;
22867 wxDateTime *result = 0 ;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 double val2 ;
22871 int ecode2 = 0 ;
22872 PyObject * obj0 = 0 ;
22873 PyObject * obj1 = 0 ;
22874 char * kwnames[] = {
22875 (char *) "self",(char *) "jdn", NULL
22876 };
22877
22878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22880 if (!SWIG_IsOK(res1)) {
22881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22882 }
22883 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22884 ecode2 = SWIG_AsVal_double(obj1, &val2);
22885 if (!SWIG_IsOK(ecode2)) {
22886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22887 }
22888 arg2 = static_cast< double >(val2);
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 {
22892 wxDateTime &_result_ref = (arg1)->Set(arg2);
22893 result = (wxDateTime *) &_result_ref;
22894 }
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22906 PyObject *resultobj = 0;
22907 wxDateTime *arg1 = (wxDateTime *) 0 ;
22908 int arg2 ;
22909 int arg3 = (int) 0 ;
22910 int arg4 = (int) 0 ;
22911 int arg5 = (int) 0 ;
22912 wxDateTime *result = 0 ;
22913 void *argp1 = 0 ;
22914 int res1 = 0 ;
22915 int val2 ;
22916 int ecode2 = 0 ;
22917 int val3 ;
22918 int ecode3 = 0 ;
22919 int val4 ;
22920 int ecode4 = 0 ;
22921 int val5 ;
22922 int ecode5 = 0 ;
22923 PyObject * obj0 = 0 ;
22924 PyObject * obj1 = 0 ;
22925 PyObject * obj2 = 0 ;
22926 PyObject * obj3 = 0 ;
22927 PyObject * obj4 = 0 ;
22928 char * kwnames[] = {
22929 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22930 };
22931
22932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22934 if (!SWIG_IsOK(res1)) {
22935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22936 }
22937 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22938 ecode2 = SWIG_AsVal_int(obj1, &val2);
22939 if (!SWIG_IsOK(ecode2)) {
22940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22941 }
22942 arg2 = static_cast< int >(val2);
22943 if (obj2) {
22944 ecode3 = SWIG_AsVal_int(obj2, &val3);
22945 if (!SWIG_IsOK(ecode3)) {
22946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22947 }
22948 arg3 = static_cast< int >(val3);
22949 }
22950 if (obj3) {
22951 ecode4 = SWIG_AsVal_int(obj3, &val4);
22952 if (!SWIG_IsOK(ecode4)) {
22953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22954 }
22955 arg4 = static_cast< int >(val4);
22956 }
22957 if (obj4) {
22958 ecode5 = SWIG_AsVal_int(obj4, &val5);
22959 if (!SWIG_IsOK(ecode5)) {
22960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22961 }
22962 arg5 = static_cast< int >(val5);
22963 }
22964 {
22965 PyThreadState* __tstate = wxPyBeginAllowThreads();
22966 {
22967 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22968 result = (wxDateTime *) &_result_ref;
22969 }
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj = 0;
22982 wxDateTime *arg1 = (wxDateTime *) 0 ;
22983 int arg2 ;
22984 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22985 int arg4 = (int) wxDateTime::Inv_Year ;
22986 int arg5 = (int) 0 ;
22987 int arg6 = (int) 0 ;
22988 int arg7 = (int) 0 ;
22989 int arg8 = (int) 0 ;
22990 wxDateTime *result = 0 ;
22991 void *argp1 = 0 ;
22992 int res1 = 0 ;
22993 int val2 ;
22994 int ecode2 = 0 ;
22995 int val3 ;
22996 int ecode3 = 0 ;
22997 int val4 ;
22998 int ecode4 = 0 ;
22999 int val5 ;
23000 int ecode5 = 0 ;
23001 int val6 ;
23002 int ecode6 = 0 ;
23003 int val7 ;
23004 int ecode7 = 0 ;
23005 int val8 ;
23006 int ecode8 = 0 ;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009 PyObject * obj2 = 0 ;
23010 PyObject * obj3 = 0 ;
23011 PyObject * obj4 = 0 ;
23012 PyObject * obj5 = 0 ;
23013 PyObject * obj6 = 0 ;
23014 PyObject * obj7 = 0 ;
23015 char * kwnames[] = {
23016 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23017 };
23018
23019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23021 if (!SWIG_IsOK(res1)) {
23022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23023 }
23024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23025 ecode2 = SWIG_AsVal_int(obj1, &val2);
23026 if (!SWIG_IsOK(ecode2)) {
23027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23028 }
23029 arg2 = static_cast< int >(val2);
23030 if (obj2) {
23031 ecode3 = SWIG_AsVal_int(obj2, &val3);
23032 if (!SWIG_IsOK(ecode3)) {
23033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23034 }
23035 arg3 = static_cast< wxDateTime::Month >(val3);
23036 }
23037 if (obj3) {
23038 ecode4 = SWIG_AsVal_int(obj3, &val4);
23039 if (!SWIG_IsOK(ecode4)) {
23040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23041 }
23042 arg4 = static_cast< int >(val4);
23043 }
23044 if (obj4) {
23045 ecode5 = SWIG_AsVal_int(obj4, &val5);
23046 if (!SWIG_IsOK(ecode5)) {
23047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23048 }
23049 arg5 = static_cast< int >(val5);
23050 }
23051 if (obj5) {
23052 ecode6 = SWIG_AsVal_int(obj5, &val6);
23053 if (!SWIG_IsOK(ecode6)) {
23054 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23055 }
23056 arg6 = static_cast< int >(val6);
23057 }
23058 if (obj6) {
23059 ecode7 = SWIG_AsVal_int(obj6, &val7);
23060 if (!SWIG_IsOK(ecode7)) {
23061 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23062 }
23063 arg7 = static_cast< int >(val7);
23064 }
23065 if (obj7) {
23066 ecode8 = SWIG_AsVal_int(obj7, &val8);
23067 if (!SWIG_IsOK(ecode8)) {
23068 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23069 }
23070 arg8 = static_cast< int >(val8);
23071 }
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 {
23075 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23076 result = (wxDateTime *) &_result_ref;
23077 }
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23089 PyObject *resultobj = 0;
23090 wxDateTime *arg1 = (wxDateTime *) 0 ;
23091 wxDateTime *result = 0 ;
23092 void *argp1 = 0 ;
23093 int res1 = 0 ;
23094 PyObject *swig_obj[1] ;
23095
23096 if (!args) SWIG_fail;
23097 swig_obj[0] = args;
23098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23099 if (!SWIG_IsOK(res1)) {
23100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23101 }
23102 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23103 {
23104 PyThreadState* __tstate = wxPyBeginAllowThreads();
23105 {
23106 wxDateTime &_result_ref = (arg1)->ResetTime();
23107 result = (wxDateTime *) &_result_ref;
23108 }
23109 wxPyEndAllowThreads(__tstate);
23110 if (PyErr_Occurred()) SWIG_fail;
23111 }
23112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23120 PyObject *resultobj = 0;
23121 wxDateTime *arg1 = (wxDateTime *) 0 ;
23122 int arg2 ;
23123 wxDateTime *result = 0 ;
23124 void *argp1 = 0 ;
23125 int res1 = 0 ;
23126 int val2 ;
23127 int ecode2 = 0 ;
23128 PyObject * obj0 = 0 ;
23129 PyObject * obj1 = 0 ;
23130 char * kwnames[] = {
23131 (char *) "self",(char *) "year", NULL
23132 };
23133
23134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23138 }
23139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23140 ecode2 = SWIG_AsVal_int(obj1, &val2);
23141 if (!SWIG_IsOK(ecode2)) {
23142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23143 }
23144 arg2 = static_cast< int >(val2);
23145 {
23146 PyThreadState* __tstate = wxPyBeginAllowThreads();
23147 {
23148 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23149 result = (wxDateTime *) &_result_ref;
23150 }
23151 wxPyEndAllowThreads(__tstate);
23152 if (PyErr_Occurred()) SWIG_fail;
23153 }
23154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23162 PyObject *resultobj = 0;
23163 wxDateTime *arg1 = (wxDateTime *) 0 ;
23164 wxDateTime::Month arg2 ;
23165 wxDateTime *result = 0 ;
23166 void *argp1 = 0 ;
23167 int res1 = 0 ;
23168 int val2 ;
23169 int ecode2 = 0 ;
23170 PyObject * obj0 = 0 ;
23171 PyObject * obj1 = 0 ;
23172 char * kwnames[] = {
23173 (char *) "self",(char *) "month", NULL
23174 };
23175
23176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23180 }
23181 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23182 ecode2 = SWIG_AsVal_int(obj1, &val2);
23183 if (!SWIG_IsOK(ecode2)) {
23184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23185 }
23186 arg2 = static_cast< wxDateTime::Month >(val2);
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 {
23190 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23191 result = (wxDateTime *) &_result_ref;
23192 }
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23204 PyObject *resultobj = 0;
23205 wxDateTime *arg1 = (wxDateTime *) 0 ;
23206 int arg2 ;
23207 wxDateTime *result = 0 ;
23208 void *argp1 = 0 ;
23209 int res1 = 0 ;
23210 int val2 ;
23211 int ecode2 = 0 ;
23212 PyObject * obj0 = 0 ;
23213 PyObject * obj1 = 0 ;
23214 char * kwnames[] = {
23215 (char *) "self",(char *) "day", NULL
23216 };
23217
23218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23220 if (!SWIG_IsOK(res1)) {
23221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23222 }
23223 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23224 ecode2 = SWIG_AsVal_int(obj1, &val2);
23225 if (!SWIG_IsOK(ecode2)) {
23226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23227 }
23228 arg2 = static_cast< int >(val2);
23229 {
23230 PyThreadState* __tstate = wxPyBeginAllowThreads();
23231 {
23232 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23233 result = (wxDateTime *) &_result_ref;
23234 }
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23239 return resultobj;
23240 fail:
23241 return NULL;
23242 }
23243
23244
23245 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23246 PyObject *resultobj = 0;
23247 wxDateTime *arg1 = (wxDateTime *) 0 ;
23248 int arg2 ;
23249 wxDateTime *result = 0 ;
23250 void *argp1 = 0 ;
23251 int res1 = 0 ;
23252 int val2 ;
23253 int ecode2 = 0 ;
23254 PyObject * obj0 = 0 ;
23255 PyObject * obj1 = 0 ;
23256 char * kwnames[] = {
23257 (char *) "self",(char *) "hour", NULL
23258 };
23259
23260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23262 if (!SWIG_IsOK(res1)) {
23263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23264 }
23265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23266 ecode2 = SWIG_AsVal_int(obj1, &val2);
23267 if (!SWIG_IsOK(ecode2)) {
23268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23269 }
23270 arg2 = static_cast< int >(val2);
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 {
23274 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23275 result = (wxDateTime *) &_result_ref;
23276 }
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23288 PyObject *resultobj = 0;
23289 wxDateTime *arg1 = (wxDateTime *) 0 ;
23290 int arg2 ;
23291 wxDateTime *result = 0 ;
23292 void *argp1 = 0 ;
23293 int res1 = 0 ;
23294 int val2 ;
23295 int ecode2 = 0 ;
23296 PyObject * obj0 = 0 ;
23297 PyObject * obj1 = 0 ;
23298 char * kwnames[] = {
23299 (char *) "self",(char *) "minute", NULL
23300 };
23301
23302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23304 if (!SWIG_IsOK(res1)) {
23305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23306 }
23307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23308 ecode2 = SWIG_AsVal_int(obj1, &val2);
23309 if (!SWIG_IsOK(ecode2)) {
23310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23311 }
23312 arg2 = static_cast< int >(val2);
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 {
23316 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23317 result = (wxDateTime *) &_result_ref;
23318 }
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 wxDateTime *arg1 = (wxDateTime *) 0 ;
23332 int arg2 ;
23333 wxDateTime *result = 0 ;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 int val2 ;
23337 int ecode2 = 0 ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char * kwnames[] = {
23341 (char *) "self",(char *) "second", NULL
23342 };
23343
23344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23346 if (!SWIG_IsOK(res1)) {
23347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23348 }
23349 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23350 ecode2 = SWIG_AsVal_int(obj1, &val2);
23351 if (!SWIG_IsOK(ecode2)) {
23352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23353 }
23354 arg2 = static_cast< int >(val2);
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 {
23358 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23359 result = (wxDateTime *) &_result_ref;
23360 }
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj = 0;
23373 wxDateTime *arg1 = (wxDateTime *) 0 ;
23374 int arg2 ;
23375 wxDateTime *result = 0 ;
23376 void *argp1 = 0 ;
23377 int res1 = 0 ;
23378 int val2 ;
23379 int ecode2 = 0 ;
23380 PyObject * obj0 = 0 ;
23381 PyObject * obj1 = 0 ;
23382 char * kwnames[] = {
23383 (char *) "self",(char *) "millisecond", NULL
23384 };
23385
23386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23388 if (!SWIG_IsOK(res1)) {
23389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23390 }
23391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23392 ecode2 = SWIG_AsVal_int(obj1, &val2);
23393 if (!SWIG_IsOK(ecode2)) {
23394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23395 }
23396 arg2 = static_cast< int >(val2);
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 {
23400 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23401 result = (wxDateTime *) &_result_ref;
23402 }
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj = 0;
23415 wxDateTime *arg1 = (wxDateTime *) 0 ;
23416 wxDateTime::WeekDay arg2 ;
23417 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23418 wxDateTime *result = 0 ;
23419 void *argp1 = 0 ;
23420 int res1 = 0 ;
23421 int val2 ;
23422 int ecode2 = 0 ;
23423 int val3 ;
23424 int ecode3 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 PyObject * obj1 = 0 ;
23427 PyObject * obj2 = 0 ;
23428 char * kwnames[] = {
23429 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23430 };
23431
23432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23434 if (!SWIG_IsOK(res1)) {
23435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23436 }
23437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23438 ecode2 = SWIG_AsVal_int(obj1, &val2);
23439 if (!SWIG_IsOK(ecode2)) {
23440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23441 }
23442 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23443 if (obj2) {
23444 ecode3 = SWIG_AsVal_int(obj2, &val3);
23445 if (!SWIG_IsOK(ecode3)) {
23446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23447 }
23448 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23449 }
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 {
23453 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23454 result = (wxDateTime *) &_result_ref;
23455 }
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj = 0;
23468 wxDateTime *arg1 = (wxDateTime *) 0 ;
23469 wxDateTime::WeekDay arg2 ;
23470 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23471 wxDateTime result;
23472 void *argp1 = 0 ;
23473 int res1 = 0 ;
23474 int val2 ;
23475 int ecode2 = 0 ;
23476 int val3 ;
23477 int ecode3 = 0 ;
23478 PyObject * obj0 = 0 ;
23479 PyObject * obj1 = 0 ;
23480 PyObject * obj2 = 0 ;
23481 char * kwnames[] = {
23482 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23483 };
23484
23485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23487 if (!SWIG_IsOK(res1)) {
23488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23489 }
23490 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23491 ecode2 = SWIG_AsVal_int(obj1, &val2);
23492 if (!SWIG_IsOK(ecode2)) {
23493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23494 }
23495 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23496 if (obj2) {
23497 ecode3 = SWIG_AsVal_int(obj2, &val3);
23498 if (!SWIG_IsOK(ecode3)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23500 }
23501 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23517 PyObject *resultobj = 0;
23518 wxDateTime *arg1 = (wxDateTime *) 0 ;
23519 wxDateTime::WeekDay arg2 ;
23520 wxDateTime *result = 0 ;
23521 void *argp1 = 0 ;
23522 int res1 = 0 ;
23523 int val2 ;
23524 int ecode2 = 0 ;
23525 PyObject * obj0 = 0 ;
23526 PyObject * obj1 = 0 ;
23527 char * kwnames[] = {
23528 (char *) "self",(char *) "weekday", NULL
23529 };
23530
23531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23533 if (!SWIG_IsOK(res1)) {
23534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23535 }
23536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23537 ecode2 = SWIG_AsVal_int(obj1, &val2);
23538 if (!SWIG_IsOK(ecode2)) {
23539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23540 }
23541 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 {
23545 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23546 result = (wxDateTime *) &_result_ref;
23547 }
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23559 PyObject *resultobj = 0;
23560 wxDateTime *arg1 = (wxDateTime *) 0 ;
23561 wxDateTime::WeekDay arg2 ;
23562 wxDateTime result;
23563 void *argp1 = 0 ;
23564 int res1 = 0 ;
23565 int val2 ;
23566 int ecode2 = 0 ;
23567 PyObject * obj0 = 0 ;
23568 PyObject * obj1 = 0 ;
23569 char * kwnames[] = {
23570 (char *) "self",(char *) "weekday", NULL
23571 };
23572
23573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23575 if (!SWIG_IsOK(res1)) {
23576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23577 }
23578 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23579 ecode2 = SWIG_AsVal_int(obj1, &val2);
23580 if (!SWIG_IsOK(ecode2)) {
23581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23582 }
23583 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23584 {
23585 PyThreadState* __tstate = wxPyBeginAllowThreads();
23586 result = (arg1)->GetNextWeekDay(arg2);
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj = 0;
23599 wxDateTime *arg1 = (wxDateTime *) 0 ;
23600 wxDateTime::WeekDay arg2 ;
23601 wxDateTime *result = 0 ;
23602 void *argp1 = 0 ;
23603 int res1 = 0 ;
23604 int val2 ;
23605 int ecode2 = 0 ;
23606 PyObject * obj0 = 0 ;
23607 PyObject * obj1 = 0 ;
23608 char * kwnames[] = {
23609 (char *) "self",(char *) "weekday", NULL
23610 };
23611
23612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23614 if (!SWIG_IsOK(res1)) {
23615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23616 }
23617 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23618 ecode2 = SWIG_AsVal_int(obj1, &val2);
23619 if (!SWIG_IsOK(ecode2)) {
23620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23621 }
23622 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 {
23626 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23627 result = (wxDateTime *) &_result_ref;
23628 }
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23633 return resultobj;
23634 fail:
23635 return NULL;
23636 }
23637
23638
23639 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj = 0;
23641 wxDateTime *arg1 = (wxDateTime *) 0 ;
23642 wxDateTime::WeekDay arg2 ;
23643 wxDateTime result;
23644 void *argp1 = 0 ;
23645 int res1 = 0 ;
23646 int val2 ;
23647 int ecode2 = 0 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 char * kwnames[] = {
23651 (char *) "self",(char *) "weekday", NULL
23652 };
23653
23654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23658 }
23659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23660 ecode2 = SWIG_AsVal_int(obj1, &val2);
23661 if (!SWIG_IsOK(ecode2)) {
23662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23663 }
23664 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23665 {
23666 PyThreadState* __tstate = wxPyBeginAllowThreads();
23667 result = (arg1)->GetPrevWeekDay(arg2);
23668 wxPyEndAllowThreads(__tstate);
23669 if (PyErr_Occurred()) SWIG_fail;
23670 }
23671 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23672 return resultobj;
23673 fail:
23674 return NULL;
23675 }
23676
23677
23678 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23679 PyObject *resultobj = 0;
23680 wxDateTime *arg1 = (wxDateTime *) 0 ;
23681 wxDateTime::WeekDay arg2 ;
23682 int arg3 = (int) 1 ;
23683 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23684 int arg5 = (int) wxDateTime::Inv_Year ;
23685 bool result;
23686 void *argp1 = 0 ;
23687 int res1 = 0 ;
23688 int val2 ;
23689 int ecode2 = 0 ;
23690 int val3 ;
23691 int ecode3 = 0 ;
23692 int val4 ;
23693 int ecode4 = 0 ;
23694 int val5 ;
23695 int ecode5 = 0 ;
23696 PyObject * obj0 = 0 ;
23697 PyObject * obj1 = 0 ;
23698 PyObject * obj2 = 0 ;
23699 PyObject * obj3 = 0 ;
23700 PyObject * obj4 = 0 ;
23701 char * kwnames[] = {
23702 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23703 };
23704
23705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23707 if (!SWIG_IsOK(res1)) {
23708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23709 }
23710 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23711 ecode2 = SWIG_AsVal_int(obj1, &val2);
23712 if (!SWIG_IsOK(ecode2)) {
23713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23714 }
23715 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23716 if (obj2) {
23717 ecode3 = SWIG_AsVal_int(obj2, &val3);
23718 if (!SWIG_IsOK(ecode3)) {
23719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23720 }
23721 arg3 = static_cast< int >(val3);
23722 }
23723 if (obj3) {
23724 ecode4 = SWIG_AsVal_int(obj3, &val4);
23725 if (!SWIG_IsOK(ecode4)) {
23726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23727 }
23728 arg4 = static_cast< wxDateTime::Month >(val4);
23729 }
23730 if (obj4) {
23731 ecode5 = SWIG_AsVal_int(obj4, &val5);
23732 if (!SWIG_IsOK(ecode5)) {
23733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23734 }
23735 arg5 = static_cast< int >(val5);
23736 }
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 {
23744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23745 }
23746 return resultobj;
23747 fail:
23748 return NULL;
23749 }
23750
23751
23752 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj = 0;
23754 wxDateTime *arg1 = (wxDateTime *) 0 ;
23755 wxDateTime::WeekDay arg2 ;
23756 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23757 int arg4 = (int) wxDateTime::Inv_Year ;
23758 bool result;
23759 void *argp1 = 0 ;
23760 int res1 = 0 ;
23761 int val2 ;
23762 int ecode2 = 0 ;
23763 int val3 ;
23764 int ecode3 = 0 ;
23765 int val4 ;
23766 int ecode4 = 0 ;
23767 PyObject * obj0 = 0 ;
23768 PyObject * obj1 = 0 ;
23769 PyObject * obj2 = 0 ;
23770 PyObject * obj3 = 0 ;
23771 char * kwnames[] = {
23772 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23773 };
23774
23775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23777 if (!SWIG_IsOK(res1)) {
23778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23779 }
23780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23781 ecode2 = SWIG_AsVal_int(obj1, &val2);
23782 if (!SWIG_IsOK(ecode2)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23784 }
23785 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23786 if (obj2) {
23787 ecode3 = SWIG_AsVal_int(obj2, &val3);
23788 if (!SWIG_IsOK(ecode3)) {
23789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23790 }
23791 arg3 = static_cast< wxDateTime::Month >(val3);
23792 }
23793 if (obj3) {
23794 ecode4 = SWIG_AsVal_int(obj3, &val4);
23795 if (!SWIG_IsOK(ecode4)) {
23796 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23797 }
23798 arg4 = static_cast< int >(val4);
23799 }
23800 {
23801 PyThreadState* __tstate = wxPyBeginAllowThreads();
23802 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23803 wxPyEndAllowThreads(__tstate);
23804 if (PyErr_Occurred()) SWIG_fail;
23805 }
23806 {
23807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23808 }
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23816 PyObject *resultobj = 0;
23817 wxDateTime *arg1 = (wxDateTime *) 0 ;
23818 wxDateTime::WeekDay arg2 ;
23819 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23820 int arg4 = (int) wxDateTime::Inv_Year ;
23821 wxDateTime result;
23822 void *argp1 = 0 ;
23823 int res1 = 0 ;
23824 int val2 ;
23825 int ecode2 = 0 ;
23826 int val3 ;
23827 int ecode3 = 0 ;
23828 int val4 ;
23829 int ecode4 = 0 ;
23830 PyObject * obj0 = 0 ;
23831 PyObject * obj1 = 0 ;
23832 PyObject * obj2 = 0 ;
23833 PyObject * obj3 = 0 ;
23834 char * kwnames[] = {
23835 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23836 };
23837
23838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23840 if (!SWIG_IsOK(res1)) {
23841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23842 }
23843 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23844 ecode2 = SWIG_AsVal_int(obj1, &val2);
23845 if (!SWIG_IsOK(ecode2)) {
23846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23847 }
23848 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23849 if (obj2) {
23850 ecode3 = SWIG_AsVal_int(obj2, &val3);
23851 if (!SWIG_IsOK(ecode3)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23853 }
23854 arg3 = static_cast< wxDateTime::Month >(val3);
23855 }
23856 if (obj3) {
23857 ecode4 = SWIG_AsVal_int(obj3, &val4);
23858 if (!SWIG_IsOK(ecode4)) {
23859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23860 }
23861 arg4 = static_cast< int >(val4);
23862 }
23863 {
23864 PyThreadState* __tstate = wxPyBeginAllowThreads();
23865 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23866 wxPyEndAllowThreads(__tstate);
23867 if (PyErr_Occurred()) SWIG_fail;
23868 }
23869 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23870 return resultobj;
23871 fail:
23872 return NULL;
23873 }
23874
23875
23876 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj = 0;
23878 wxDateTime *arg1 = (wxDateTime *) 0 ;
23879 int arg2 ;
23880 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23881 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23882 bool result;
23883 void *argp1 = 0 ;
23884 int res1 = 0 ;
23885 int val2 ;
23886 int ecode2 = 0 ;
23887 int val3 ;
23888 int ecode3 = 0 ;
23889 int val4 ;
23890 int ecode4 = 0 ;
23891 PyObject * obj0 = 0 ;
23892 PyObject * obj1 = 0 ;
23893 PyObject * obj2 = 0 ;
23894 PyObject * obj3 = 0 ;
23895 char * kwnames[] = {
23896 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23897 };
23898
23899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23901 if (!SWIG_IsOK(res1)) {
23902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23903 }
23904 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23905 ecode2 = SWIG_AsVal_int(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23908 }
23909 arg2 = static_cast< int >(val2);
23910 if (obj2) {
23911 ecode3 = SWIG_AsVal_int(obj2, &val3);
23912 if (!SWIG_IsOK(ecode3)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23914 }
23915 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23916 }
23917 if (obj3) {
23918 ecode4 = SWIG_AsVal_int(obj3, &val4);
23919 if (!SWIG_IsOK(ecode4)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23921 }
23922 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23923 }
23924 {
23925 PyThreadState* __tstate = wxPyBeginAllowThreads();
23926 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 {
23931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23932 }
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj = 0;
23941 wxDateTime *arg1 = (wxDateTime *) 0 ;
23942 int arg2 ;
23943 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23944 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23945 wxDateTime result;
23946 void *argp1 = 0 ;
23947 int res1 = 0 ;
23948 int val2 ;
23949 int ecode2 = 0 ;
23950 int val3 ;
23951 int ecode3 = 0 ;
23952 int val4 ;
23953 int ecode4 = 0 ;
23954 PyObject * obj0 = 0 ;
23955 PyObject * obj1 = 0 ;
23956 PyObject * obj2 = 0 ;
23957 PyObject * obj3 = 0 ;
23958 char * kwnames[] = {
23959 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23960 };
23961
23962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23964 if (!SWIG_IsOK(res1)) {
23965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23966 }
23967 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23968 ecode2 = SWIG_AsVal_int(obj1, &val2);
23969 if (!SWIG_IsOK(ecode2)) {
23970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23971 }
23972 arg2 = static_cast< int >(val2);
23973 if (obj2) {
23974 ecode3 = SWIG_AsVal_int(obj2, &val3);
23975 if (!SWIG_IsOK(ecode3)) {
23976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23977 }
23978 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23979 }
23980 if (obj3) {
23981 ecode4 = SWIG_AsVal_int(obj3, &val4);
23982 if (!SWIG_IsOK(ecode4)) {
23983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23984 }
23985 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23986 }
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = (arg1)->GetWeek(arg2,arg3,arg4);
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23994 return resultobj;
23995 fail:
23996 return NULL;
23997 }
23998
23999
24000 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj = 0;
24002 int arg1 ;
24003 int arg2 ;
24004 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24005 wxDateTime result;
24006 int val1 ;
24007 int ecode1 = 0 ;
24008 int val2 ;
24009 int ecode2 = 0 ;
24010 int val3 ;
24011 int ecode3 = 0 ;
24012 PyObject * obj0 = 0 ;
24013 PyObject * obj1 = 0 ;
24014 PyObject * obj2 = 0 ;
24015 char * kwnames[] = {
24016 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24017 };
24018
24019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24020 ecode1 = SWIG_AsVal_int(obj0, &val1);
24021 if (!SWIG_IsOK(ecode1)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24023 }
24024 arg1 = static_cast< int >(val1);
24025 ecode2 = SWIG_AsVal_int(obj1, &val2);
24026 if (!SWIG_IsOK(ecode2)) {
24027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24028 }
24029 arg2 = static_cast< int >(val2);
24030 if (obj2) {
24031 ecode3 = SWIG_AsVal_int(obj2, &val3);
24032 if (!SWIG_IsOK(ecode3)) {
24033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24034 }
24035 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24036 }
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24040 wxPyEndAllowThreads(__tstate);
24041 if (PyErr_Occurred()) SWIG_fail;
24042 }
24043 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24051 PyObject *resultobj = 0;
24052 wxDateTime *arg1 = (wxDateTime *) 0 ;
24053 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24054 int arg3 = (int) wxDateTime::Inv_Year ;
24055 wxDateTime *result = 0 ;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 int val2 ;
24059 int ecode2 = 0 ;
24060 int val3 ;
24061 int ecode3 = 0 ;
24062 PyObject * obj0 = 0 ;
24063 PyObject * obj1 = 0 ;
24064 PyObject * obj2 = 0 ;
24065 char * kwnames[] = {
24066 (char *) "self",(char *) "month",(char *) "year", NULL
24067 };
24068
24069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24073 }
24074 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24075 if (obj1) {
24076 ecode2 = SWIG_AsVal_int(obj1, &val2);
24077 if (!SWIG_IsOK(ecode2)) {
24078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24079 }
24080 arg2 = static_cast< wxDateTime::Month >(val2);
24081 }
24082 if (obj2) {
24083 ecode3 = SWIG_AsVal_int(obj2, &val3);
24084 if (!SWIG_IsOK(ecode3)) {
24085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24086 }
24087 arg3 = static_cast< int >(val3);
24088 }
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 {
24092 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24093 result = (wxDateTime *) &_result_ref;
24094 }
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj = 0;
24107 wxDateTime *arg1 = (wxDateTime *) 0 ;
24108 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24109 int arg3 = (int) wxDateTime::Inv_Year ;
24110 wxDateTime result;
24111 void *argp1 = 0 ;
24112 int res1 = 0 ;
24113 int val2 ;
24114 int ecode2 = 0 ;
24115 int val3 ;
24116 int ecode3 = 0 ;
24117 PyObject * obj0 = 0 ;
24118 PyObject * obj1 = 0 ;
24119 PyObject * obj2 = 0 ;
24120 char * kwnames[] = {
24121 (char *) "self",(char *) "month",(char *) "year", NULL
24122 };
24123
24124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24128 }
24129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24130 if (obj1) {
24131 ecode2 = SWIG_AsVal_int(obj1, &val2);
24132 if (!SWIG_IsOK(ecode2)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24134 }
24135 arg2 = static_cast< wxDateTime::Month >(val2);
24136 }
24137 if (obj2) {
24138 ecode3 = SWIG_AsVal_int(obj2, &val3);
24139 if (!SWIG_IsOK(ecode3)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24141 }
24142 arg3 = static_cast< int >(val3);
24143 }
24144 {
24145 PyThreadState* __tstate = wxPyBeginAllowThreads();
24146 result = (arg1)->GetLastMonthDay(arg2,arg3);
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24158 PyObject *resultobj = 0;
24159 wxDateTime *arg1 = (wxDateTime *) 0 ;
24160 int arg2 ;
24161 wxDateTime *result = 0 ;
24162 void *argp1 = 0 ;
24163 int res1 = 0 ;
24164 int val2 ;
24165 int ecode2 = 0 ;
24166 PyObject * obj0 = 0 ;
24167 PyObject * obj1 = 0 ;
24168 char * kwnames[] = {
24169 (char *) "self",(char *) "yday", NULL
24170 };
24171
24172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24174 if (!SWIG_IsOK(res1)) {
24175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24176 }
24177 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24178 ecode2 = SWIG_AsVal_int(obj1, &val2);
24179 if (!SWIG_IsOK(ecode2)) {
24180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24181 }
24182 arg2 = static_cast< int >(val2);
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 {
24186 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24187 result = (wxDateTime *) &_result_ref;
24188 }
24189 wxPyEndAllowThreads(__tstate);
24190 if (PyErr_Occurred()) SWIG_fail;
24191 }
24192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24200 PyObject *resultobj = 0;
24201 wxDateTime *arg1 = (wxDateTime *) 0 ;
24202 int arg2 ;
24203 wxDateTime result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 int val2 ;
24207 int ecode2 = 0 ;
24208 PyObject * obj0 = 0 ;
24209 PyObject * obj1 = 0 ;
24210 char * kwnames[] = {
24211 (char *) "self",(char *) "yday", NULL
24212 };
24213
24214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24216 if (!SWIG_IsOK(res1)) {
24217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24218 }
24219 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24220 ecode2 = SWIG_AsVal_int(obj1, &val2);
24221 if (!SWIG_IsOK(ecode2)) {
24222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24223 }
24224 arg2 = static_cast< int >(val2);
24225 {
24226 PyThreadState* __tstate = wxPyBeginAllowThreads();
24227 result = (arg1)->GetYearDay(arg2);
24228 wxPyEndAllowThreads(__tstate);
24229 if (PyErr_Occurred()) SWIG_fail;
24230 }
24231 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24232 return resultobj;
24233 fail:
24234 return NULL;
24235 }
24236
24237
24238 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24239 PyObject *resultobj = 0;
24240 wxDateTime *arg1 = (wxDateTime *) 0 ;
24241 double result;
24242 void *argp1 = 0 ;
24243 int res1 = 0 ;
24244 PyObject *swig_obj[1] ;
24245
24246 if (!args) SWIG_fail;
24247 swig_obj[0] = args;
24248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24249 if (!SWIG_IsOK(res1)) {
24250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24251 }
24252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24253 {
24254 PyThreadState* __tstate = wxPyBeginAllowThreads();
24255 result = (double)(arg1)->GetJulianDayNumber();
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_From_double(static_cast< double >(result));
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *resultobj = 0;
24268 wxDateTime *arg1 = (wxDateTime *) 0 ;
24269 double result;
24270 void *argp1 = 0 ;
24271 int res1 = 0 ;
24272 PyObject *swig_obj[1] ;
24273
24274 if (!args) SWIG_fail;
24275 swig_obj[0] = args;
24276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24279 }
24280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (double)(arg1)->GetJDN();
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_From_double(static_cast< double >(result));
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxDateTime *arg1 = (wxDateTime *) 0 ;
24297 double result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24307 }
24308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_From_double(static_cast< double >(result));
24316 return resultobj;
24317 fail:
24318 return NULL;
24319 }
24320
24321
24322 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24323 PyObject *resultobj = 0;
24324 wxDateTime *arg1 = (wxDateTime *) 0 ;
24325 double result;
24326 void *argp1 = 0 ;
24327 int res1 = 0 ;
24328 PyObject *swig_obj[1] ;
24329
24330 if (!args) SWIG_fail;
24331 swig_obj[0] = args;
24332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24333 if (!SWIG_IsOK(res1)) {
24334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24335 }
24336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24337 {
24338 PyThreadState* __tstate = wxPyBeginAllowThreads();
24339 result = (double)(arg1)->GetMJD();
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_From_double(static_cast< double >(result));
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24351 PyObject *resultobj = 0;
24352 wxDateTime *arg1 = (wxDateTime *) 0 ;
24353 double result;
24354 void *argp1 = 0 ;
24355 int res1 = 0 ;
24356 PyObject *swig_obj[1] ;
24357
24358 if (!args) SWIG_fail;
24359 swig_obj[0] = args;
24360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24361 if (!SWIG_IsOK(res1)) {
24362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24363 }
24364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 result = (double)(arg1)->GetRataDie();
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_From_double(static_cast< double >(result));
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj = 0;
24380 wxDateTime *arg1 = (wxDateTime *) 0 ;
24381 wxDateTime::TimeZone *arg2 = 0 ;
24382 bool arg3 = (bool) false ;
24383 wxDateTime result;
24384 void *argp1 = 0 ;
24385 int res1 = 0 ;
24386 bool temp2 = false ;
24387 bool val3 ;
24388 int ecode3 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 PyObject * obj2 = 0 ;
24392 char * kwnames[] = {
24393 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24394 };
24395
24396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24398 if (!SWIG_IsOK(res1)) {
24399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24400 }
24401 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24402 {
24403 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24404 temp2 = true;
24405 }
24406 if (obj2) {
24407 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24408 if (!SWIG_IsOK(ecode3)) {
24409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24410 }
24411 arg3 = static_cast< bool >(val3);
24412 }
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24416 wxPyEndAllowThreads(__tstate);
24417 if (PyErr_Occurred()) SWIG_fail;
24418 }
24419 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24420 {
24421 if (temp2) delete arg2;
24422 }
24423 return resultobj;
24424 fail:
24425 {
24426 if (temp2) delete arg2;
24427 }
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj = 0;
24434 wxDateTime *arg1 = (wxDateTime *) 0 ;
24435 wxDateTime::TimeZone *arg2 = 0 ;
24436 bool arg3 = (bool) false ;
24437 wxDateTime *result = 0 ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool temp2 = false ;
24441 bool val3 ;
24442 int ecode3 = 0 ;
24443 PyObject * obj0 = 0 ;
24444 PyObject * obj1 = 0 ;
24445 PyObject * obj2 = 0 ;
24446 char * kwnames[] = {
24447 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24448 };
24449
24450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24452 if (!SWIG_IsOK(res1)) {
24453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24454 }
24455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24456 {
24457 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24458 temp2 = true;
24459 }
24460 if (obj2) {
24461 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24462 if (!SWIG_IsOK(ecode3)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24464 }
24465 arg3 = static_cast< bool >(val3);
24466 }
24467 {
24468 PyThreadState* __tstate = wxPyBeginAllowThreads();
24469 {
24470 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24471 result = (wxDateTime *) &_result_ref;
24472 }
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24477 {
24478 if (temp2) delete arg2;
24479 }
24480 return resultobj;
24481 fail:
24482 {
24483 if (temp2) delete arg2;
24484 }
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24490 PyObject *resultobj = 0;
24491 wxDateTime *arg1 = (wxDateTime *) 0 ;
24492 wxDateTime::TimeZone *arg2 = 0 ;
24493 bool arg3 = (bool) false ;
24494 wxDateTime result;
24495 void *argp1 = 0 ;
24496 int res1 = 0 ;
24497 bool temp2 = false ;
24498 bool val3 ;
24499 int ecode3 = 0 ;
24500 PyObject * obj0 = 0 ;
24501 PyObject * obj1 = 0 ;
24502 PyObject * obj2 = 0 ;
24503 char * kwnames[] = {
24504 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24505 };
24506
24507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24509 if (!SWIG_IsOK(res1)) {
24510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24511 }
24512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24513 {
24514 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24515 temp2 = true;
24516 }
24517 if (obj2) {
24518 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24519 if (!SWIG_IsOK(ecode3)) {
24520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24521 }
24522 arg3 = static_cast< bool >(val3);
24523 }
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24531 {
24532 if (temp2) delete arg2;
24533 }
24534 return resultobj;
24535 fail:
24536 {
24537 if (temp2) delete arg2;
24538 }
24539 return NULL;
24540 }
24541
24542
24543 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24544 PyObject *resultobj = 0;
24545 wxDateTime *arg1 = (wxDateTime *) 0 ;
24546 wxDateTime::TimeZone *arg2 = 0 ;
24547 bool arg3 = (bool) false ;
24548 wxDateTime *result = 0 ;
24549 void *argp1 = 0 ;
24550 int res1 = 0 ;
24551 bool temp2 = false ;
24552 bool val3 ;
24553 int ecode3 = 0 ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 PyObject * obj2 = 0 ;
24557 char * kwnames[] = {
24558 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24559 };
24560
24561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24565 }
24566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24567 {
24568 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24569 temp2 = true;
24570 }
24571 if (obj2) {
24572 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24573 if (!SWIG_IsOK(ecode3)) {
24574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24575 }
24576 arg3 = static_cast< bool >(val3);
24577 }
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 {
24581 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24582 result = (wxDateTime *) &_result_ref;
24583 }
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24588 {
24589 if (temp2) delete arg2;
24590 }
24591 return resultobj;
24592 fail:
24593 {
24594 if (temp2) delete arg2;
24595 }
24596 return NULL;
24597 }
24598
24599
24600 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24601 PyObject *resultobj = 0;
24602 wxDateTime *arg1 = (wxDateTime *) 0 ;
24603 bool arg2 = (bool) false ;
24604 wxDateTime result;
24605 void *argp1 = 0 ;
24606 int res1 = 0 ;
24607 bool val2 ;
24608 int ecode2 = 0 ;
24609 PyObject * obj0 = 0 ;
24610 PyObject * obj1 = 0 ;
24611 char * kwnames[] = {
24612 (char *) "self",(char *) "noDST", NULL
24613 };
24614
24615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24617 if (!SWIG_IsOK(res1)) {
24618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24619 }
24620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24621 if (obj1) {
24622 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24623 if (!SWIG_IsOK(ecode2)) {
24624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24625 }
24626 arg2 = static_cast< bool >(val2);
24627 }
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj = 0;
24643 wxDateTime *arg1 = (wxDateTime *) 0 ;
24644 bool arg2 = (bool) false ;
24645 wxDateTime *result = 0 ;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 bool val2 ;
24649 int ecode2 = 0 ;
24650 PyObject * obj0 = 0 ;
24651 PyObject * obj1 = 0 ;
24652 char * kwnames[] = {
24653 (char *) "self",(char *) "noDST", NULL
24654 };
24655
24656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24658 if (!SWIG_IsOK(res1)) {
24659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24660 }
24661 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24662 if (obj1) {
24663 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24664 if (!SWIG_IsOK(ecode2)) {
24665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24666 }
24667 arg2 = static_cast< bool >(val2);
24668 }
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 {
24672 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24673 result = (wxDateTime *) &_result_ref;
24674 }
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24686 PyObject *resultobj = 0;
24687 wxDateTime *arg1 = (wxDateTime *) 0 ;
24688 bool arg2 = (bool) false ;
24689 wxDateTime result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 bool val2 ;
24693 int ecode2 = 0 ;
24694 PyObject * obj0 = 0 ;
24695 PyObject * obj1 = 0 ;
24696 char * kwnames[] = {
24697 (char *) "self",(char *) "noDST", NULL
24698 };
24699
24700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24702 if (!SWIG_IsOK(res1)) {
24703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24704 }
24705 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24706 if (obj1) {
24707 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24708 if (!SWIG_IsOK(ecode2)) {
24709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24710 }
24711 arg2 = static_cast< bool >(val2);
24712 }
24713 {
24714 PyThreadState* __tstate = wxPyBeginAllowThreads();
24715 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24727 PyObject *resultobj = 0;
24728 wxDateTime *arg1 = (wxDateTime *) 0 ;
24729 bool arg2 = (bool) false ;
24730 wxDateTime *result = 0 ;
24731 void *argp1 = 0 ;
24732 int res1 = 0 ;
24733 bool val2 ;
24734 int ecode2 = 0 ;
24735 PyObject * obj0 = 0 ;
24736 PyObject * obj1 = 0 ;
24737 char * kwnames[] = {
24738 (char *) "self",(char *) "noDST", NULL
24739 };
24740
24741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24743 if (!SWIG_IsOK(res1)) {
24744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24745 }
24746 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24747 if (obj1) {
24748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24749 if (!SWIG_IsOK(ecode2)) {
24750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24751 }
24752 arg2 = static_cast< bool >(val2);
24753 }
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 {
24757 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24758 result = (wxDateTime *) &_result_ref;
24759 }
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj = 0;
24772 wxDateTime *arg1 = (wxDateTime *) 0 ;
24773 bool arg2 = (bool) false ;
24774 wxDateTime result;
24775 void *argp1 = 0 ;
24776 int res1 = 0 ;
24777 bool val2 ;
24778 int ecode2 = 0 ;
24779 PyObject * obj0 = 0 ;
24780 PyObject * obj1 = 0 ;
24781 char * kwnames[] = {
24782 (char *) "self",(char *) "noDST", NULL
24783 };
24784
24785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24787 if (!SWIG_IsOK(res1)) {
24788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24789 }
24790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24791 if (obj1) {
24792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24793 if (!SWIG_IsOK(ecode2)) {
24794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24795 }
24796 arg2 = static_cast< bool >(val2);
24797 }
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24801 wxPyEndAllowThreads(__tstate);
24802 if (PyErr_Occurred()) SWIG_fail;
24803 }
24804 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj = 0;
24813 wxDateTime *arg1 = (wxDateTime *) 0 ;
24814 bool arg2 = (bool) false ;
24815 wxDateTime *result = 0 ;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 bool val2 ;
24819 int ecode2 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char * kwnames[] = {
24823 (char *) "self",(char *) "noDST", NULL
24824 };
24825
24826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24828 if (!SWIG_IsOK(res1)) {
24829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24830 }
24831 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24832 if (obj1) {
24833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24834 if (!SWIG_IsOK(ecode2)) {
24835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24836 }
24837 arg2 = static_cast< bool >(val2);
24838 }
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 {
24842 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24843 result = (wxDateTime *) &_result_ref;
24844 }
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24849 return resultobj;
24850 fail:
24851 return NULL;
24852 }
24853
24854
24855 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24856 PyObject *resultobj = 0;
24857 wxDateTime *arg1 = (wxDateTime *) 0 ;
24858 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24859 int result;
24860 void *argp1 = 0 ;
24861 int res1 = 0 ;
24862 int val2 ;
24863 int ecode2 = 0 ;
24864 PyObject * obj0 = 0 ;
24865 PyObject * obj1 = 0 ;
24866 char * kwnames[] = {
24867 (char *) "self",(char *) "country", NULL
24868 };
24869
24870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24874 }
24875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24876 if (obj1) {
24877 ecode2 = SWIG_AsVal_int(obj1, &val2);
24878 if (!SWIG_IsOK(ecode2)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24880 }
24881 arg2 = static_cast< wxDateTime::Country >(val2);
24882 }
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = (int)(arg1)->IsDST(arg2);
24886 wxPyEndAllowThreads(__tstate);
24887 if (PyErr_Occurred()) SWIG_fail;
24888 }
24889 resultobj = SWIG_From_int(static_cast< int >(result));
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24897 PyObject *resultobj = 0;
24898 wxDateTime *arg1 = (wxDateTime *) 0 ;
24899 bool result;
24900 void *argp1 = 0 ;
24901 int res1 = 0 ;
24902 PyObject *swig_obj[1] ;
24903
24904 if (!args) SWIG_fail;
24905 swig_obj[0] = args;
24906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24909 }
24910 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxDateTime const *)arg1)->IsValid();
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 {
24918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24919 }
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24927 PyObject *resultobj = 0;
24928 wxDateTime *arg1 = (wxDateTime *) 0 ;
24929 time_t result;
24930 void *argp1 = 0 ;
24931 int res1 = 0 ;
24932 PyObject *swig_obj[1] ;
24933
24934 if (!args) SWIG_fail;
24935 swig_obj[0] = args;
24936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24939 }
24940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24955 PyObject *resultobj = 0;
24956 wxDateTime *arg1 = (wxDateTime *) 0 ;
24957 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24958 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24959 int result;
24960 void *argp1 = 0 ;
24961 int res1 = 0 ;
24962 bool temp2 = false ;
24963 PyObject * obj0 = 0 ;
24964 PyObject * obj1 = 0 ;
24965 char * kwnames[] = {
24966 (char *) "self",(char *) "tz", NULL
24967 };
24968
24969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24973 }
24974 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24975 if (obj1) {
24976 {
24977 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24978 temp2 = true;
24979 }
24980 }
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 resultobj = SWIG_From_int(static_cast< int >(result));
24988 {
24989 if (temp2) delete arg2;
24990 }
24991 return resultobj;
24992 fail:
24993 {
24994 if (temp2) delete arg2;
24995 }
24996 return NULL;
24997 }
24998
24999
25000 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25001 PyObject *resultobj = 0;
25002 wxDateTime *arg1 = (wxDateTime *) 0 ;
25003 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25004 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25005 wxDateTime::Month result;
25006 void *argp1 = 0 ;
25007 int res1 = 0 ;
25008 bool temp2 = false ;
25009 PyObject * obj0 = 0 ;
25010 PyObject * obj1 = 0 ;
25011 char * kwnames[] = {
25012 (char *) "self",(char *) "tz", NULL
25013 };
25014
25015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25017 if (!SWIG_IsOK(res1)) {
25018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25019 }
25020 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25021 if (obj1) {
25022 {
25023 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25024 temp2 = true;
25025 }
25026 }
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 resultobj = SWIG_From_int(static_cast< int >(result));
25034 {
25035 if (temp2) delete arg2;
25036 }
25037 return resultobj;
25038 fail:
25039 {
25040 if (temp2) delete arg2;
25041 }
25042 return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25047 PyObject *resultobj = 0;
25048 wxDateTime *arg1 = (wxDateTime *) 0 ;
25049 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25050 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25051 int result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 bool temp2 = false ;
25055 PyObject * obj0 = 0 ;
25056 PyObject * obj1 = 0 ;
25057 char * kwnames[] = {
25058 (char *) "self",(char *) "tz", NULL
25059 };
25060
25061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25063 if (!SWIG_IsOK(res1)) {
25064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25065 }
25066 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25067 if (obj1) {
25068 {
25069 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25070 temp2 = true;
25071 }
25072 }
25073 {
25074 PyThreadState* __tstate = wxPyBeginAllowThreads();
25075 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25076 wxPyEndAllowThreads(__tstate);
25077 if (PyErr_Occurred()) SWIG_fail;
25078 }
25079 resultobj = SWIG_From_int(static_cast< int >(result));
25080 {
25081 if (temp2) delete arg2;
25082 }
25083 return resultobj;
25084 fail:
25085 {
25086 if (temp2) delete arg2;
25087 }
25088 return NULL;
25089 }
25090
25091
25092 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25093 PyObject *resultobj = 0;
25094 wxDateTime *arg1 = (wxDateTime *) 0 ;
25095 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25096 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25097 wxDateTime::WeekDay result;
25098 void *argp1 = 0 ;
25099 int res1 = 0 ;
25100 bool temp2 = false ;
25101 PyObject * obj0 = 0 ;
25102 PyObject * obj1 = 0 ;
25103 char * kwnames[] = {
25104 (char *) "self",(char *) "tz", NULL
25105 };
25106
25107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25109 if (!SWIG_IsOK(res1)) {
25110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25111 }
25112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25113 if (obj1) {
25114 {
25115 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25116 temp2 = true;
25117 }
25118 }
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 resultobj = SWIG_From_int(static_cast< int >(result));
25126 {
25127 if (temp2) delete arg2;
25128 }
25129 return resultobj;
25130 fail:
25131 {
25132 if (temp2) delete arg2;
25133 }
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj = 0;
25140 wxDateTime *arg1 = (wxDateTime *) 0 ;
25141 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25142 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25143 int result;
25144 void *argp1 = 0 ;
25145 int res1 = 0 ;
25146 bool temp2 = false ;
25147 PyObject * obj0 = 0 ;
25148 PyObject * obj1 = 0 ;
25149 char * kwnames[] = {
25150 (char *) "self",(char *) "tz", NULL
25151 };
25152
25153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25155 if (!SWIG_IsOK(res1)) {
25156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25157 }
25158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25159 if (obj1) {
25160 {
25161 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25162 temp2 = true;
25163 }
25164 }
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 resultobj = SWIG_From_int(static_cast< int >(result));
25172 {
25173 if (temp2) delete arg2;
25174 }
25175 return resultobj;
25176 fail:
25177 {
25178 if (temp2) delete arg2;
25179 }
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj = 0;
25186 wxDateTime *arg1 = (wxDateTime *) 0 ;
25187 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25188 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25189 int result;
25190 void *argp1 = 0 ;
25191 int res1 = 0 ;
25192 bool temp2 = false ;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 char * kwnames[] = {
25196 (char *) "self",(char *) "tz", NULL
25197 };
25198
25199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25201 if (!SWIG_IsOK(res1)) {
25202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25203 }
25204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25205 if (obj1) {
25206 {
25207 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25208 temp2 = true;
25209 }
25210 }
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_From_int(static_cast< int >(result));
25218 {
25219 if (temp2) delete arg2;
25220 }
25221 return resultobj;
25222 fail:
25223 {
25224 if (temp2) delete arg2;
25225 }
25226 return NULL;
25227 }
25228
25229
25230 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj = 0;
25232 wxDateTime *arg1 = (wxDateTime *) 0 ;
25233 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25234 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25235 int result;
25236 void *argp1 = 0 ;
25237 int res1 = 0 ;
25238 bool temp2 = false ;
25239 PyObject * obj0 = 0 ;
25240 PyObject * obj1 = 0 ;
25241 char * kwnames[] = {
25242 (char *) "self",(char *) "tz", NULL
25243 };
25244
25245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25247 if (!SWIG_IsOK(res1)) {
25248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25249 }
25250 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25251 if (obj1) {
25252 {
25253 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25254 temp2 = true;
25255 }
25256 }
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 resultobj = SWIG_From_int(static_cast< int >(result));
25264 {
25265 if (temp2) delete arg2;
25266 }
25267 return resultobj;
25268 fail:
25269 {
25270 if (temp2) delete arg2;
25271 }
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25277 PyObject *resultobj = 0;
25278 wxDateTime *arg1 = (wxDateTime *) 0 ;
25279 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25280 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25281 int result;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 bool temp2 = false ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 char * kwnames[] = {
25288 (char *) "self",(char *) "tz", NULL
25289 };
25290
25291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25293 if (!SWIG_IsOK(res1)) {
25294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25295 }
25296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25297 if (obj1) {
25298 {
25299 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25300 temp2 = true;
25301 }
25302 }
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 resultobj = SWIG_From_int(static_cast< int >(result));
25310 {
25311 if (temp2) delete arg2;
25312 }
25313 return resultobj;
25314 fail:
25315 {
25316 if (temp2) delete arg2;
25317 }
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj = 0;
25324 wxDateTime *arg1 = (wxDateTime *) 0 ;
25325 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25326 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25327 int result;
25328 void *argp1 = 0 ;
25329 int res1 = 0 ;
25330 bool temp2 = false ;
25331 PyObject * obj0 = 0 ;
25332 PyObject * obj1 = 0 ;
25333 char * kwnames[] = {
25334 (char *) "self",(char *) "tz", NULL
25335 };
25336
25337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25339 if (!SWIG_IsOK(res1)) {
25340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25341 }
25342 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25343 if (obj1) {
25344 {
25345 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25346 temp2 = true;
25347 }
25348 }
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 resultobj = SWIG_From_int(static_cast< int >(result));
25356 {
25357 if (temp2) delete arg2;
25358 }
25359 return resultobj;
25360 fail:
25361 {
25362 if (temp2) delete arg2;
25363 }
25364 return NULL;
25365 }
25366
25367
25368 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25369 PyObject *resultobj = 0;
25370 wxDateTime *arg1 = (wxDateTime *) 0 ;
25371 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25372 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25373 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25374 int result;
25375 void *argp1 = 0 ;
25376 int res1 = 0 ;
25377 int val2 ;
25378 int ecode2 = 0 ;
25379 bool temp3 = false ;
25380 PyObject * obj0 = 0 ;
25381 PyObject * obj1 = 0 ;
25382 PyObject * obj2 = 0 ;
25383 char * kwnames[] = {
25384 (char *) "self",(char *) "flags",(char *) "tz", NULL
25385 };
25386
25387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25389 if (!SWIG_IsOK(res1)) {
25390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25391 }
25392 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25393 if (obj1) {
25394 ecode2 = SWIG_AsVal_int(obj1, &val2);
25395 if (!SWIG_IsOK(ecode2)) {
25396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25397 }
25398 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25399 }
25400 if (obj2) {
25401 {
25402 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25403 temp3 = true;
25404 }
25405 }
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 resultobj = SWIG_From_int(static_cast< int >(result));
25413 {
25414 if (temp3) delete arg3;
25415 }
25416 return resultobj;
25417 fail:
25418 {
25419 if (temp3) delete arg3;
25420 }
25421 return NULL;
25422 }
25423
25424
25425 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25426 PyObject *resultobj = 0;
25427 wxDateTime *arg1 = (wxDateTime *) 0 ;
25428 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25429 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25430 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25431 int result;
25432 void *argp1 = 0 ;
25433 int res1 = 0 ;
25434 int val2 ;
25435 int ecode2 = 0 ;
25436 bool temp3 = false ;
25437 PyObject * obj0 = 0 ;
25438 PyObject * obj1 = 0 ;
25439 PyObject * obj2 = 0 ;
25440 char * kwnames[] = {
25441 (char *) "self",(char *) "flags",(char *) "tz", NULL
25442 };
25443
25444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25448 }
25449 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25450 if (obj1) {
25451 ecode2 = SWIG_AsVal_int(obj1, &val2);
25452 if (!SWIG_IsOK(ecode2)) {
25453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25454 }
25455 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25456 }
25457 if (obj2) {
25458 {
25459 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25460 temp3 = true;
25461 }
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_From_int(static_cast< int >(result));
25470 {
25471 if (temp3) delete arg3;
25472 }
25473 return resultobj;
25474 fail:
25475 {
25476 if (temp3) delete arg3;
25477 }
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj = 0;
25484 wxDateTime *arg1 = (wxDateTime *) 0 ;
25485 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25486 bool result;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 int val2 ;
25490 int ecode2 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "self",(char *) "country", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25501 }
25502 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25503 if (obj1) {
25504 ecode2 = SWIG_AsVal_int(obj1, &val2);
25505 if (!SWIG_IsOK(ecode2)) {
25506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25507 }
25508 arg2 = static_cast< wxDateTime::Country >(val2);
25509 }
25510 {
25511 PyThreadState* __tstate = wxPyBeginAllowThreads();
25512 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 {
25517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25518 }
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25526 PyObject *resultobj = 0;
25527 wxDateTime *arg1 = (wxDateTime *) 0 ;
25528 wxDateTime *arg2 = 0 ;
25529 bool result;
25530 void *argp1 = 0 ;
25531 int res1 = 0 ;
25532 void *argp2 = 0 ;
25533 int res2 = 0 ;
25534 PyObject * obj0 = 0 ;
25535 PyObject * obj1 = 0 ;
25536 char * kwnames[] = {
25537 (char *) "self",(char *) "datetime", NULL
25538 };
25539
25540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25542 if (!SWIG_IsOK(res1)) {
25543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25544 }
25545 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25547 if (!SWIG_IsOK(res2)) {
25548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25549 }
25550 if (!argp2) {
25551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25552 }
25553 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25554 {
25555 PyThreadState* __tstate = wxPyBeginAllowThreads();
25556 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25557 wxPyEndAllowThreads(__tstate);
25558 if (PyErr_Occurred()) SWIG_fail;
25559 }
25560 {
25561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25562 }
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj = 0;
25571 wxDateTime *arg1 = (wxDateTime *) 0 ;
25572 wxDateTime *arg2 = 0 ;
25573 bool result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 void *argp2 = 0 ;
25577 int res2 = 0 ;
25578 PyObject * obj0 = 0 ;
25579 PyObject * obj1 = 0 ;
25580 char * kwnames[] = {
25581 (char *) "self",(char *) "datetime", NULL
25582 };
25583
25584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25586 if (!SWIG_IsOK(res1)) {
25587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25588 }
25589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25590 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25591 if (!SWIG_IsOK(res2)) {
25592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25593 }
25594 if (!argp2) {
25595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25596 }
25597 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj = 0;
25615 wxDateTime *arg1 = (wxDateTime *) 0 ;
25616 wxDateTime *arg2 = 0 ;
25617 bool result;
25618 void *argp1 = 0 ;
25619 int res1 = 0 ;
25620 void *argp2 = 0 ;
25621 int res2 = 0 ;
25622 PyObject * obj0 = 0 ;
25623 PyObject * obj1 = 0 ;
25624 char * kwnames[] = {
25625 (char *) "self",(char *) "datetime", NULL
25626 };
25627
25628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25630 if (!SWIG_IsOK(res1)) {
25631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25632 }
25633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25634 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25635 if (!SWIG_IsOK(res2)) {
25636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25637 }
25638 if (!argp2) {
25639 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25640 }
25641 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 {
25649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25650 }
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25658 PyObject *resultobj = 0;
25659 wxDateTime *arg1 = (wxDateTime *) 0 ;
25660 wxDateTime *arg2 = 0 ;
25661 wxDateTime *arg3 = 0 ;
25662 bool result;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 void *argp2 = 0 ;
25666 int res2 = 0 ;
25667 void *argp3 = 0 ;
25668 int res3 = 0 ;
25669 PyObject * obj0 = 0 ;
25670 PyObject * obj1 = 0 ;
25671 PyObject * obj2 = 0 ;
25672 char * kwnames[] = {
25673 (char *) "self",(char *) "t1",(char *) "t2", NULL
25674 };
25675
25676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25678 if (!SWIG_IsOK(res1)) {
25679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25680 }
25681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25683 if (!SWIG_IsOK(res2)) {
25684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25685 }
25686 if (!argp2) {
25687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25688 }
25689 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25690 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25691 if (!SWIG_IsOK(res3)) {
25692 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25693 }
25694 if (!argp3) {
25695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25696 }
25697 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 {
25705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25706 }
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj = 0;
25715 wxDateTime *arg1 = (wxDateTime *) 0 ;
25716 wxDateTime *arg2 = 0 ;
25717 wxDateTime *arg3 = 0 ;
25718 bool result;
25719 void *argp1 = 0 ;
25720 int res1 = 0 ;
25721 void *argp2 = 0 ;
25722 int res2 = 0 ;
25723 void *argp3 = 0 ;
25724 int res3 = 0 ;
25725 PyObject * obj0 = 0 ;
25726 PyObject * obj1 = 0 ;
25727 PyObject * obj2 = 0 ;
25728 char * kwnames[] = {
25729 (char *) "self",(char *) "t1",(char *) "t2", NULL
25730 };
25731
25732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25739 if (!SWIG_IsOK(res2)) {
25740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25741 }
25742 if (!argp2) {
25743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25744 }
25745 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25746 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25747 if (!SWIG_IsOK(res3)) {
25748 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25749 }
25750 if (!argp3) {
25751 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25752 }
25753 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25770 PyObject *resultobj = 0;
25771 wxDateTime *arg1 = (wxDateTime *) 0 ;
25772 wxDateTime *arg2 = 0 ;
25773 bool result;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 void *argp2 = 0 ;
25777 int res2 = 0 ;
25778 PyObject * obj0 = 0 ;
25779 PyObject * obj1 = 0 ;
25780 char * kwnames[] = {
25781 (char *) "self",(char *) "dt", NULL
25782 };
25783
25784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25788 }
25789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25790 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25791 if (!SWIG_IsOK(res2)) {
25792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25793 }
25794 if (!argp2) {
25795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25796 }
25797 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj = 0;
25815 wxDateTime *arg1 = (wxDateTime *) 0 ;
25816 wxDateTime *arg2 = 0 ;
25817 bool result;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 void *argp2 = 0 ;
25821 int res2 = 0 ;
25822 PyObject * obj0 = 0 ;
25823 PyObject * obj1 = 0 ;
25824 char * kwnames[] = {
25825 (char *) "self",(char *) "dt", NULL
25826 };
25827
25828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25830 if (!SWIG_IsOK(res1)) {
25831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25832 }
25833 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25834 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25835 if (!SWIG_IsOK(res2)) {
25836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25837 }
25838 if (!argp2) {
25839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25840 }
25841 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj = 0;
25859 wxDateTime *arg1 = (wxDateTime *) 0 ;
25860 wxDateTime *arg2 = 0 ;
25861 wxTimeSpan *arg3 = 0 ;
25862 bool result;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 void *argp2 = 0 ;
25866 int res2 = 0 ;
25867 void *argp3 = 0 ;
25868 int res3 = 0 ;
25869 PyObject * obj0 = 0 ;
25870 PyObject * obj1 = 0 ;
25871 PyObject * obj2 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "self",(char *) "dt",(char *) "ts", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25878 if (!SWIG_IsOK(res1)) {
25879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25880 }
25881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25883 if (!SWIG_IsOK(res2)) {
25884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25885 }
25886 if (!argp2) {
25887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25888 }
25889 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25890 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25891 if (!SWIG_IsOK(res3)) {
25892 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25893 }
25894 if (!argp3) {
25895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25896 }
25897 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 {
25905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25906 }
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25914 PyObject *resultobj = 0;
25915 wxDateTime *arg1 = (wxDateTime *) 0 ;
25916 wxTimeSpan *arg2 = 0 ;
25917 wxDateTime *result = 0 ;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 void *argp2 = 0 ;
25921 int res2 = 0 ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char * kwnames[] = {
25925 (char *) "self",(char *) "diff", NULL
25926 };
25927
25928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25932 }
25933 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25935 if (!SWIG_IsOK(res2)) {
25936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25937 }
25938 if (!argp2) {
25939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25940 }
25941 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25942 {
25943 PyThreadState* __tstate = wxPyBeginAllowThreads();
25944 {
25945 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25946 result = (wxDateTime *) &_result_ref;
25947 }
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = 0;
25960 wxDateTime *arg1 = (wxDateTime *) 0 ;
25961 wxDateSpan *arg2 = 0 ;
25962 wxDateTime *result = 0 ;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 void *argp2 = 0 ;
25966 int res2 = 0 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char * kwnames[] = {
25970 (char *) "self",(char *) "diff", NULL
25971 };
25972
25973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25975 if (!SWIG_IsOK(res1)) {
25976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25977 }
25978 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25980 if (!SWIG_IsOK(res2)) {
25981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25982 }
25983 if (!argp2) {
25984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25985 }
25986 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 {
25990 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25991 result = (wxDateTime *) &_result_ref;
25992 }
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25997 return resultobj;
25998 fail:
25999 return NULL;
26000 }
26001
26002
26003 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26004 PyObject *resultobj = 0;
26005 wxDateTime *arg1 = (wxDateTime *) 0 ;
26006 wxTimeSpan *arg2 = 0 ;
26007 wxDateTime *result = 0 ;
26008 void *argp1 = 0 ;
26009 int res1 = 0 ;
26010 void *argp2 = 0 ;
26011 int res2 = 0 ;
26012 PyObject * obj0 = 0 ;
26013 PyObject * obj1 = 0 ;
26014 char * kwnames[] = {
26015 (char *) "self",(char *) "diff", NULL
26016 };
26017
26018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26020 if (!SWIG_IsOK(res1)) {
26021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26022 }
26023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26025 if (!SWIG_IsOK(res2)) {
26026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26027 }
26028 if (!argp2) {
26029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26030 }
26031 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 {
26035 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26036 result = (wxDateTime *) &_result_ref;
26037 }
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj = 0;
26050 wxDateTime *arg1 = (wxDateTime *) 0 ;
26051 wxDateSpan *arg2 = 0 ;
26052 wxDateTime *result = 0 ;
26053 void *argp1 = 0 ;
26054 int res1 = 0 ;
26055 void *argp2 = 0 ;
26056 int res2 = 0 ;
26057 PyObject * obj0 = 0 ;
26058 PyObject * obj1 = 0 ;
26059 char * kwnames[] = {
26060 (char *) "self",(char *) "diff", NULL
26061 };
26062
26063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26065 if (!SWIG_IsOK(res1)) {
26066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26067 }
26068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26070 if (!SWIG_IsOK(res2)) {
26071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26072 }
26073 if (!argp2) {
26074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26075 }
26076 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 {
26080 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26081 result = (wxDateTime *) &_result_ref;
26082 }
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj = 0;
26095 wxDateTime *arg1 = (wxDateTime *) 0 ;
26096 wxDateTime *arg2 = 0 ;
26097 wxTimeSpan result;
26098 void *argp1 = 0 ;
26099 int res1 = 0 ;
26100 void *argp2 = 0 ;
26101 int res2 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "self",(char *) "dt", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26110 if (!SWIG_IsOK(res1)) {
26111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26112 }
26113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26115 if (!SWIG_IsOK(res2)) {
26116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26117 }
26118 if (!argp2) {
26119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26120 }
26121 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26136 PyObject *resultobj = 0;
26137 wxDateTime *arg1 = (wxDateTime *) 0 ;
26138 wxTimeSpan *arg2 = 0 ;
26139 wxDateTime *result = 0 ;
26140 void *argp1 = 0 ;
26141 int res1 = 0 ;
26142 void *argp2 = 0 ;
26143 int res2 = 0 ;
26144
26145 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26147 if (!SWIG_IsOK(res1)) {
26148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26149 }
26150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26151 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26152 if (!SWIG_IsOK(res2)) {
26153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26154 }
26155 if (!argp2) {
26156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26157 }
26158 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26159 {
26160 PyThreadState* __tstate = wxPyBeginAllowThreads();
26161 {
26162 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26163 result = (wxDateTime *) &_result_ref;
26164 }
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26176 PyObject *resultobj = 0;
26177 wxDateTime *arg1 = (wxDateTime *) 0 ;
26178 wxDateSpan *arg2 = 0 ;
26179 wxDateTime *result = 0 ;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 void *argp2 = 0 ;
26183 int res2 = 0 ;
26184
26185 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26189 }
26190 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26191 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26192 if (!SWIG_IsOK(res2)) {
26193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26194 }
26195 if (!argp2) {
26196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26197 }
26198 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 {
26202 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26203 result = (wxDateTime *) &_result_ref;
26204 }
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26216 int argc;
26217 PyObject *argv[3];
26218
26219 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26220 --argc;
26221 if (argc == 2) {
26222 int _v = 0;
26223 {
26224 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26225 _v = SWIG_CheckState(res);
26226 }
26227 if (!_v) goto check_1;
26228 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26229 }
26230 check_1:
26231
26232 if (argc == 2) {
26233 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26234 }
26235
26236 fail:
26237 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26243 PyObject *resultobj = 0;
26244 wxDateTime *arg1 = (wxDateTime *) 0 ;
26245 wxTimeSpan *arg2 = 0 ;
26246 wxDateTime *result = 0 ;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 void *argp2 = 0 ;
26250 int res2 = 0 ;
26251
26252 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26254 if (!SWIG_IsOK(res1)) {
26255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26256 }
26257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26258 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26259 if (!SWIG_IsOK(res2)) {
26260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26261 }
26262 if (!argp2) {
26263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26264 }
26265 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 {
26269 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26270 result = (wxDateTime *) &_result_ref;
26271 }
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26276 return resultobj;
26277 fail:
26278 return NULL;
26279 }
26280
26281
26282 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26283 PyObject *resultobj = 0;
26284 wxDateTime *arg1 = (wxDateTime *) 0 ;
26285 wxDateSpan *arg2 = 0 ;
26286 wxDateTime *result = 0 ;
26287 void *argp1 = 0 ;
26288 int res1 = 0 ;
26289 void *argp2 = 0 ;
26290 int res2 = 0 ;
26291
26292 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26294 if (!SWIG_IsOK(res1)) {
26295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26296 }
26297 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26299 if (!SWIG_IsOK(res2)) {
26300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26301 }
26302 if (!argp2) {
26303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26304 }
26305 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 {
26309 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26310 result = (wxDateTime *) &_result_ref;
26311 }
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26323 int argc;
26324 PyObject *argv[3];
26325
26326 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26327 --argc;
26328 if (argc == 2) {
26329 int _v = 0;
26330 {
26331 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26332 _v = SWIG_CheckState(res);
26333 }
26334 if (!_v) goto check_1;
26335 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26336 }
26337 check_1:
26338
26339 if (argc == 2) {
26340 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26341 }
26342
26343 fail:
26344 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26345 return NULL;
26346 }
26347
26348
26349 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26350 PyObject *resultobj = 0;
26351 wxDateTime *arg1 = (wxDateTime *) 0 ;
26352 wxTimeSpan *arg2 = 0 ;
26353 wxDateTime result;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 void *argp2 = 0 ;
26357 int res2 = 0 ;
26358
26359 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26361 if (!SWIG_IsOK(res1)) {
26362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26363 }
26364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26365 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26366 if (!SWIG_IsOK(res2)) {
26367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26368 }
26369 if (!argp2) {
26370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26371 }
26372 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26380 return resultobj;
26381 fail:
26382 return NULL;
26383 }
26384
26385
26386 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26387 PyObject *resultobj = 0;
26388 wxDateTime *arg1 = (wxDateTime *) 0 ;
26389 wxDateSpan *arg2 = 0 ;
26390 wxDateTime result;
26391 void *argp1 = 0 ;
26392 int res1 = 0 ;
26393 void *argp2 = 0 ;
26394 int res2 = 0 ;
26395
26396 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26398 if (!SWIG_IsOK(res1)) {
26399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26400 }
26401 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26403 if (!SWIG_IsOK(res2)) {
26404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26405 }
26406 if (!argp2) {
26407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26408 }
26409 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26424 int argc;
26425 PyObject *argv[3];
26426
26427 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26428 --argc;
26429 if (argc == 2) {
26430 int _v = 0;
26431 {
26432 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26433 _v = SWIG_CheckState(res);
26434 }
26435 if (!_v) goto check_1;
26436 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26437 }
26438 check_1:
26439
26440 if (argc == 2) {
26441 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26442 }
26443
26444 fail:
26445 Py_INCREF(Py_NotImplemented);
26446 return Py_NotImplemented;
26447 }
26448
26449
26450 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26451 PyObject *resultobj = 0;
26452 wxDateTime *arg1 = (wxDateTime *) 0 ;
26453 wxDateTime *arg2 = 0 ;
26454 wxTimeSpan result;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 void *argp2 = 0 ;
26458 int res2 = 0 ;
26459
26460 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26464 }
26465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26466 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26467 if (!SWIG_IsOK(res2)) {
26468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26469 }
26470 if (!argp2) {
26471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26472 }
26473 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26474 {
26475 PyThreadState* __tstate = wxPyBeginAllowThreads();
26476 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26477 wxPyEndAllowThreads(__tstate);
26478 if (PyErr_Occurred()) SWIG_fail;
26479 }
26480 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26488 PyObject *resultobj = 0;
26489 wxDateTime *arg1 = (wxDateTime *) 0 ;
26490 wxTimeSpan *arg2 = 0 ;
26491 wxDateTime result;
26492 void *argp1 = 0 ;
26493 int res1 = 0 ;
26494 void *argp2 = 0 ;
26495 int res2 = 0 ;
26496
26497 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26499 if (!SWIG_IsOK(res1)) {
26500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26501 }
26502 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26503 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26504 if (!SWIG_IsOK(res2)) {
26505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26506 }
26507 if (!argp2) {
26508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26509 }
26510 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26525 PyObject *resultobj = 0;
26526 wxDateTime *arg1 = (wxDateTime *) 0 ;
26527 wxDateSpan *arg2 = 0 ;
26528 wxDateTime result;
26529 void *argp1 = 0 ;
26530 int res1 = 0 ;
26531 void *argp2 = 0 ;
26532 int res2 = 0 ;
26533
26534 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26536 if (!SWIG_IsOK(res1)) {
26537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26538 }
26539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26541 if (!SWIG_IsOK(res2)) {
26542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26543 }
26544 if (!argp2) {
26545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26546 }
26547 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26562 int argc;
26563 PyObject *argv[3];
26564
26565 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26566 --argc;
26567 if (argc == 2) {
26568 int _v = 0;
26569 {
26570 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26571 _v = SWIG_CheckState(res);
26572 }
26573 if (!_v) goto check_1;
26574 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26575 }
26576 check_1:
26577
26578 if (argc == 2) {
26579 int _v = 0;
26580 {
26581 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26582 _v = SWIG_CheckState(res);
26583 }
26584 if (!_v) goto check_2;
26585 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26586 }
26587 check_2:
26588
26589 if (argc == 2) {
26590 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26591 }
26592
26593 fail:
26594 Py_INCREF(Py_NotImplemented);
26595 return Py_NotImplemented;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj = 0;
26601 wxDateTime *arg1 = (wxDateTime *) 0 ;
26602 wxDateTime *arg2 = (wxDateTime *) 0 ;
26603 bool result;
26604 void *argp1 = 0 ;
26605 int res1 = 0 ;
26606 void *argp2 = 0 ;
26607 int res2 = 0 ;
26608 PyObject * obj0 = 0 ;
26609 PyObject * obj1 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "self",(char *) "other", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26621 if (!SWIG_IsOK(res2)) {
26622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26623 }
26624 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 {
26632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26633 }
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj = 0;
26642 wxDateTime *arg1 = (wxDateTime *) 0 ;
26643 wxDateTime *arg2 = (wxDateTime *) 0 ;
26644 bool result;
26645 void *argp1 = 0 ;
26646 int res1 = 0 ;
26647 void *argp2 = 0 ;
26648 int res2 = 0 ;
26649 PyObject * obj0 = 0 ;
26650 PyObject * obj1 = 0 ;
26651 char * kwnames[] = {
26652 (char *) "self",(char *) "other", NULL
26653 };
26654
26655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26657 if (!SWIG_IsOK(res1)) {
26658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26659 }
26660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26662 if (!SWIG_IsOK(res2)) {
26663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26664 }
26665 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 {
26673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26674 }
26675 return resultobj;
26676 fail:
26677 return NULL;
26678 }
26679
26680
26681 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj = 0;
26683 wxDateTime *arg1 = (wxDateTime *) 0 ;
26684 wxDateTime *arg2 = (wxDateTime *) 0 ;
26685 bool result;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 void *argp2 = 0 ;
26689 int res2 = 0 ;
26690 PyObject * obj0 = 0 ;
26691 PyObject * obj1 = 0 ;
26692 char * kwnames[] = {
26693 (char *) "self",(char *) "other", NULL
26694 };
26695
26696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26698 if (!SWIG_IsOK(res1)) {
26699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26700 }
26701 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26703 if (!SWIG_IsOK(res2)) {
26704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26705 }
26706 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 {
26714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26715 }
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26723 PyObject *resultobj = 0;
26724 wxDateTime *arg1 = (wxDateTime *) 0 ;
26725 wxDateTime *arg2 = (wxDateTime *) 0 ;
26726 bool result;
26727 void *argp1 = 0 ;
26728 int res1 = 0 ;
26729 void *argp2 = 0 ;
26730 int res2 = 0 ;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733 char * kwnames[] = {
26734 (char *) "self",(char *) "other", NULL
26735 };
26736
26737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26739 if (!SWIG_IsOK(res1)) {
26740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26741 }
26742 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26744 if (!SWIG_IsOK(res2)) {
26745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26746 }
26747 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 {
26755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26756 }
26757 return resultobj;
26758 fail:
26759 return NULL;
26760 }
26761
26762
26763 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26764 PyObject *resultobj = 0;
26765 wxDateTime *arg1 = (wxDateTime *) 0 ;
26766 wxDateTime *arg2 = (wxDateTime *) 0 ;
26767 bool result;
26768 void *argp1 = 0 ;
26769 int res1 = 0 ;
26770 void *argp2 = 0 ;
26771 int res2 = 0 ;
26772 PyObject * obj0 = 0 ;
26773 PyObject * obj1 = 0 ;
26774 char * kwnames[] = {
26775 (char *) "self",(char *) "other", NULL
26776 };
26777
26778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26782 }
26783 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26785 if (!SWIG_IsOK(res2)) {
26786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26787 }
26788 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26792 wxPyEndAllowThreads(__tstate);
26793 if (PyErr_Occurred()) SWIG_fail;
26794 }
26795 {
26796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26797 }
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj = 0;
26806 wxDateTime *arg1 = (wxDateTime *) 0 ;
26807 wxDateTime *arg2 = (wxDateTime *) 0 ;
26808 bool result;
26809 void *argp1 = 0 ;
26810 int res1 = 0 ;
26811 void *argp2 = 0 ;
26812 int res2 = 0 ;
26813 PyObject * obj0 = 0 ;
26814 PyObject * obj1 = 0 ;
26815 char * kwnames[] = {
26816 (char *) "self",(char *) "other", NULL
26817 };
26818
26819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26821 if (!SWIG_IsOK(res1)) {
26822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26823 }
26824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26826 if (!SWIG_IsOK(res2)) {
26827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26828 }
26829 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26830 {
26831 PyThreadState* __tstate = wxPyBeginAllowThreads();
26832 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 {
26837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26838 }
26839 return resultobj;
26840 fail:
26841 return NULL;
26842 }
26843
26844
26845 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = 0;
26847 wxDateTime *arg1 = (wxDateTime *) 0 ;
26848 wxString *arg2 = 0 ;
26849 int result;
26850 void *argp1 = 0 ;
26851 int res1 = 0 ;
26852 bool temp2 = false ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "date", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26863 }
26864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26865 {
26866 arg2 = wxString_in_helper(obj1);
26867 if (arg2 == NULL) SWIG_fail;
26868 temp2 = true;
26869 }
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 resultobj = SWIG_From_int(static_cast< int >(result));
26877 {
26878 if (temp2)
26879 delete arg2;
26880 }
26881 return resultobj;
26882 fail:
26883 {
26884 if (temp2)
26885 delete arg2;
26886 }
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26892 PyObject *resultobj = 0;
26893 wxDateTime *arg1 = (wxDateTime *) 0 ;
26894 wxString *arg2 = 0 ;
26895 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26896 wxString *arg3 = (wxString *) &arg3_defvalue ;
26897 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26898 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26899 int result;
26900 void *argp1 = 0 ;
26901 int res1 = 0 ;
26902 bool temp2 = false ;
26903 bool temp3 = false ;
26904 void *argp4 = 0 ;
26905 int res4 = 0 ;
26906 PyObject * obj0 = 0 ;
26907 PyObject * obj1 = 0 ;
26908 PyObject * obj2 = 0 ;
26909 PyObject * obj3 = 0 ;
26910 char * kwnames[] = {
26911 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26912 };
26913
26914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26916 if (!SWIG_IsOK(res1)) {
26917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26918 }
26919 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26920 {
26921 arg2 = wxString_in_helper(obj1);
26922 if (arg2 == NULL) SWIG_fail;
26923 temp2 = true;
26924 }
26925 if (obj2) {
26926 {
26927 arg3 = wxString_in_helper(obj2);
26928 if (arg3 == NULL) SWIG_fail;
26929 temp3 = true;
26930 }
26931 }
26932 if (obj3) {
26933 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26934 if (!SWIG_IsOK(res4)) {
26935 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26936 }
26937 if (!argp4) {
26938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26939 }
26940 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26941 }
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 resultobj = SWIG_From_int(static_cast< int >(result));
26949 {
26950 if (temp2)
26951 delete arg2;
26952 }
26953 {
26954 if (temp3)
26955 delete arg3;
26956 }
26957 return resultobj;
26958 fail:
26959 {
26960 if (temp2)
26961 delete arg2;
26962 }
26963 {
26964 if (temp3)
26965 delete arg3;
26966 }
26967 return NULL;
26968 }
26969
26970
26971 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj = 0;
26973 wxDateTime *arg1 = (wxDateTime *) 0 ;
26974 wxString *arg2 = 0 ;
26975 int result;
26976 void *argp1 = 0 ;
26977 int res1 = 0 ;
26978 bool temp2 = false ;
26979 PyObject * obj0 = 0 ;
26980 PyObject * obj1 = 0 ;
26981 char * kwnames[] = {
26982 (char *) "self",(char *) "datetime", NULL
26983 };
26984
26985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26987 if (!SWIG_IsOK(res1)) {
26988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26989 }
26990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26991 {
26992 arg2 = wxString_in_helper(obj1);
26993 if (arg2 == NULL) SWIG_fail;
26994 temp2 = true;
26995 }
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 resultobj = SWIG_From_int(static_cast< int >(result));
27003 {
27004 if (temp2)
27005 delete arg2;
27006 }
27007 return resultobj;
27008 fail:
27009 {
27010 if (temp2)
27011 delete arg2;
27012 }
27013 return NULL;
27014 }
27015
27016
27017 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj = 0;
27019 wxDateTime *arg1 = (wxDateTime *) 0 ;
27020 wxString *arg2 = 0 ;
27021 int result;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 bool temp2 = false ;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 char * kwnames[] = {
27028 (char *) "self",(char *) "date", NULL
27029 };
27030
27031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27033 if (!SWIG_IsOK(res1)) {
27034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27035 }
27036 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27037 {
27038 arg2 = wxString_in_helper(obj1);
27039 if (arg2 == NULL) SWIG_fail;
27040 temp2 = true;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 resultobj = SWIG_From_int(static_cast< int >(result));
27049 {
27050 if (temp2)
27051 delete arg2;
27052 }
27053 return resultobj;
27054 fail:
27055 {
27056 if (temp2)
27057 delete arg2;
27058 }
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27064 PyObject *resultobj = 0;
27065 wxDateTime *arg1 = (wxDateTime *) 0 ;
27066 wxString *arg2 = 0 ;
27067 int result;
27068 void *argp1 = 0 ;
27069 int res1 = 0 ;
27070 bool temp2 = false ;
27071 PyObject * obj0 = 0 ;
27072 PyObject * obj1 = 0 ;
27073 char * kwnames[] = {
27074 (char *) "self",(char *) "time", NULL
27075 };
27076
27077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27079 if (!SWIG_IsOK(res1)) {
27080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27081 }
27082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27083 {
27084 arg2 = wxString_in_helper(obj1);
27085 if (arg2 == NULL) SWIG_fail;
27086 temp2 = true;
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_From_int(static_cast< int >(result));
27095 {
27096 if (temp2)
27097 delete arg2;
27098 }
27099 return resultobj;
27100 fail:
27101 {
27102 if (temp2)
27103 delete arg2;
27104 }
27105 return NULL;
27106 }
27107
27108
27109 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27110 PyObject *resultobj = 0;
27111 wxDateTime *arg1 = (wxDateTime *) 0 ;
27112 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27113 wxString *arg2 = (wxString *) &arg2_defvalue ;
27114 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27115 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27116 wxString result;
27117 void *argp1 = 0 ;
27118 int res1 = 0 ;
27119 bool temp2 = false ;
27120 bool temp3 = false ;
27121 PyObject * obj0 = 0 ;
27122 PyObject * obj1 = 0 ;
27123 PyObject * obj2 = 0 ;
27124 char * kwnames[] = {
27125 (char *) "self",(char *) "format",(char *) "tz", NULL
27126 };
27127
27128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27130 if (!SWIG_IsOK(res1)) {
27131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27132 }
27133 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27134 if (obj1) {
27135 {
27136 arg2 = wxString_in_helper(obj1);
27137 if (arg2 == NULL) SWIG_fail;
27138 temp2 = true;
27139 }
27140 }
27141 if (obj2) {
27142 {
27143 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27144 temp3 = true;
27145 }
27146 }
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 {
27154 #if wxUSE_UNICODE
27155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27156 #else
27157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27158 #endif
27159 }
27160 {
27161 if (temp2)
27162 delete arg2;
27163 }
27164 {
27165 if (temp3) delete arg3;
27166 }
27167 return resultobj;
27168 fail:
27169 {
27170 if (temp2)
27171 delete arg2;
27172 }
27173 {
27174 if (temp3) delete arg3;
27175 }
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27181 PyObject *resultobj = 0;
27182 wxDateTime *arg1 = (wxDateTime *) 0 ;
27183 wxString result;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 PyObject *swig_obj[1] ;
27187
27188 if (!args) SWIG_fail;
27189 swig_obj[0] = args;
27190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27193 }
27194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = ((wxDateTime const *)arg1)->FormatDate();
27198 wxPyEndAllowThreads(__tstate);
27199 if (PyErr_Occurred()) SWIG_fail;
27200 }
27201 {
27202 #if wxUSE_UNICODE
27203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27204 #else
27205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27206 #endif
27207 }
27208 return resultobj;
27209 fail:
27210 return NULL;
27211 }
27212
27213
27214 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27215 PyObject *resultobj = 0;
27216 wxDateTime *arg1 = (wxDateTime *) 0 ;
27217 wxString result;
27218 void *argp1 = 0 ;
27219 int res1 = 0 ;
27220 PyObject *swig_obj[1] ;
27221
27222 if (!args) SWIG_fail;
27223 swig_obj[0] = args;
27224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27225 if (!SWIG_IsOK(res1)) {
27226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27227 }
27228 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = ((wxDateTime const *)arg1)->FormatTime();
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 {
27236 #if wxUSE_UNICODE
27237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27238 #else
27239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27240 #endif
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27249 PyObject *resultobj = 0;
27250 wxDateTime *arg1 = (wxDateTime *) 0 ;
27251 wxString result;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 PyObject *swig_obj[1] ;
27255
27256 if (!args) SWIG_fail;
27257 swig_obj[0] = args;
27258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27259 if (!SWIG_IsOK(res1)) {
27260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27261 }
27262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 result = ((wxDateTime const *)arg1)->FormatISODate();
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 {
27270 #if wxUSE_UNICODE
27271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27272 #else
27273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27274 #endif
27275 }
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27283 PyObject *resultobj = 0;
27284 wxDateTime *arg1 = (wxDateTime *) 0 ;
27285 wxString result;
27286 void *argp1 = 0 ;
27287 int res1 = 0 ;
27288 PyObject *swig_obj[1] ;
27289
27290 if (!args) SWIG_fail;
27291 swig_obj[0] = args;
27292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27295 }
27296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = ((wxDateTime const *)arg1)->FormatISOTime();
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 {
27304 #if wxUSE_UNICODE
27305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27306 #else
27307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27308 #endif
27309 }
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27317 PyObject *obj;
27318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27319 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27320 return SWIG_Py_Void();
27321 }
27322
27323 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27324 return SWIG_Python_InitShadowInstance(args);
27325 }
27326
27327 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj = 0;
27329 long arg1 ;
27330 wxTimeSpan result;
27331 long val1 ;
27332 int ecode1 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 char * kwnames[] = {
27335 (char *) "ms", NULL
27336 };
27337
27338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27339 ecode1 = SWIG_AsVal_long(obj0, &val1);
27340 if (!SWIG_IsOK(ecode1)) {
27341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27342 }
27343 arg1 = static_cast< long >(val1);
27344 {
27345 PyThreadState* __tstate = wxPyBeginAllowThreads();
27346 result = wxTimeSpan::Milliseconds(arg1);
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27358 PyObject *resultobj = 0;
27359 wxTimeSpan result;
27360
27361 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27362 {
27363 PyThreadState* __tstate = wxPyBeginAllowThreads();
27364 result = wxTimeSpan::Millisecond();
27365 wxPyEndAllowThreads(__tstate);
27366 if (PyErr_Occurred()) SWIG_fail;
27367 }
27368 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj = 0;
27377 long arg1 ;
27378 wxTimeSpan result;
27379 long val1 ;
27380 int ecode1 = 0 ;
27381 PyObject * obj0 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "sec", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27387 ecode1 = SWIG_AsVal_long(obj0, &val1);
27388 if (!SWIG_IsOK(ecode1)) {
27389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27390 }
27391 arg1 = static_cast< long >(val1);
27392 {
27393 PyThreadState* __tstate = wxPyBeginAllowThreads();
27394 result = wxTimeSpan::Seconds(arg1);
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27406 PyObject *resultobj = 0;
27407 wxTimeSpan result;
27408
27409 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27410 {
27411 PyThreadState* __tstate = wxPyBeginAllowThreads();
27412 result = wxTimeSpan::Second();
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj = 0;
27425 long arg1 ;
27426 wxTimeSpan result;
27427 long val1 ;
27428 int ecode1 = 0 ;
27429 PyObject * obj0 = 0 ;
27430 char * kwnames[] = {
27431 (char *) "min", NULL
27432 };
27433
27434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27435 ecode1 = SWIG_AsVal_long(obj0, &val1);
27436 if (!SWIG_IsOK(ecode1)) {
27437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27438 }
27439 arg1 = static_cast< long >(val1);
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 result = wxTimeSpan::Minutes(arg1);
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxTimeSpan result;
27456
27457 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = wxTimeSpan::Minute();
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj = 0;
27473 long arg1 ;
27474 wxTimeSpan result;
27475 long val1 ;
27476 int ecode1 = 0 ;
27477 PyObject * obj0 = 0 ;
27478 char * kwnames[] = {
27479 (char *) "hours", NULL
27480 };
27481
27482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27483 ecode1 = SWIG_AsVal_long(obj0, &val1);
27484 if (!SWIG_IsOK(ecode1)) {
27485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27486 }
27487 arg1 = static_cast< long >(val1);
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 result = wxTimeSpan::Hours(arg1);
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *resultobj = 0;
27503 wxTimeSpan result;
27504
27505 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = wxTimeSpan::Hour();
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27513 return resultobj;
27514 fail:
27515 return NULL;
27516 }
27517
27518
27519 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27520 PyObject *resultobj = 0;
27521 long arg1 ;
27522 wxTimeSpan result;
27523 long val1 ;
27524 int ecode1 = 0 ;
27525 PyObject * obj0 = 0 ;
27526 char * kwnames[] = {
27527 (char *) "days", NULL
27528 };
27529
27530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27531 ecode1 = SWIG_AsVal_long(obj0, &val1);
27532 if (!SWIG_IsOK(ecode1)) {
27533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27534 }
27535 arg1 = static_cast< long >(val1);
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = wxTimeSpan::Days(arg1);
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 PyObject *resultobj = 0;
27551 wxTimeSpan result;
27552
27553 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = wxTimeSpan::Day();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27568 PyObject *resultobj = 0;
27569 long arg1 ;
27570 wxTimeSpan result;
27571 long val1 ;
27572 int ecode1 = 0 ;
27573 PyObject * obj0 = 0 ;
27574 char * kwnames[] = {
27575 (char *) "days", NULL
27576 };
27577
27578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27579 ecode1 = SWIG_AsVal_long(obj0, &val1);
27580 if (!SWIG_IsOK(ecode1)) {
27581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27582 }
27583 arg1 = static_cast< long >(val1);
27584 {
27585 PyThreadState* __tstate = wxPyBeginAllowThreads();
27586 result = wxTimeSpan::Weeks(arg1);
27587 wxPyEndAllowThreads(__tstate);
27588 if (PyErr_Occurred()) SWIG_fail;
27589 }
27590 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27598 PyObject *resultobj = 0;
27599 wxTimeSpan result;
27600
27601 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = wxTimeSpan::Week();
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27616 PyObject *resultobj = 0;
27617 long arg1 = (long) 0 ;
27618 long arg2 = (long) 0 ;
27619 long arg3 = (long) 0 ;
27620 long arg4 = (long) 0 ;
27621 wxTimeSpan *result = 0 ;
27622 long val1 ;
27623 int ecode1 = 0 ;
27624 long val2 ;
27625 int ecode2 = 0 ;
27626 long val3 ;
27627 int ecode3 = 0 ;
27628 long val4 ;
27629 int ecode4 = 0 ;
27630 PyObject * obj0 = 0 ;
27631 PyObject * obj1 = 0 ;
27632 PyObject * obj2 = 0 ;
27633 PyObject * obj3 = 0 ;
27634 char * kwnames[] = {
27635 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27636 };
27637
27638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27639 if (obj0) {
27640 ecode1 = SWIG_AsVal_long(obj0, &val1);
27641 if (!SWIG_IsOK(ecode1)) {
27642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27643 }
27644 arg1 = static_cast< long >(val1);
27645 }
27646 if (obj1) {
27647 ecode2 = SWIG_AsVal_long(obj1, &val2);
27648 if (!SWIG_IsOK(ecode2)) {
27649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27650 }
27651 arg2 = static_cast< long >(val2);
27652 }
27653 if (obj2) {
27654 ecode3 = SWIG_AsVal_long(obj2, &val3);
27655 if (!SWIG_IsOK(ecode3)) {
27656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27657 }
27658 arg3 = static_cast< long >(val3);
27659 }
27660 if (obj3) {
27661 ecode4 = SWIG_AsVal_long(obj3, &val4);
27662 if (!SWIG_IsOK(ecode4)) {
27663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27664 }
27665 arg4 = static_cast< long >(val4);
27666 }
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27681 PyObject *resultobj = 0;
27682 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27683 void *argp1 = 0 ;
27684 int res1 = 0 ;
27685 PyObject *swig_obj[1] ;
27686
27687 if (!args) SWIG_fail;
27688 swig_obj[0] = args;
27689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27690 if (!SWIG_IsOK(res1)) {
27691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27692 }
27693 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27694 {
27695 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 delete arg1;
27697
27698 wxPyEndAllowThreads(__tstate);
27699 if (PyErr_Occurred()) SWIG_fail;
27700 }
27701 resultobj = SWIG_Py_Void();
27702 return resultobj;
27703 fail:
27704 return NULL;
27705 }
27706
27707
27708 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27709 PyObject *resultobj = 0;
27710 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27711 wxTimeSpan *arg2 = 0 ;
27712 wxTimeSpan *result = 0 ;
27713 void *argp1 = 0 ;
27714 int res1 = 0 ;
27715 void *argp2 = 0 ;
27716 int res2 = 0 ;
27717 PyObject * obj0 = 0 ;
27718 PyObject * obj1 = 0 ;
27719 char * kwnames[] = {
27720 (char *) "self",(char *) "diff", NULL
27721 };
27722
27723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27725 if (!SWIG_IsOK(res1)) {
27726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27727 }
27728 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27729 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27730 if (!SWIG_IsOK(res2)) {
27731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27732 }
27733 if (!argp2) {
27734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27735 }
27736 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 {
27740 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27741 result = (wxTimeSpan *) &_result_ref;
27742 }
27743 wxPyEndAllowThreads(__tstate);
27744 if (PyErr_Occurred()) SWIG_fail;
27745 }
27746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj = 0;
27755 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27756 wxTimeSpan *arg2 = 0 ;
27757 wxTimeSpan *result = 0 ;
27758 void *argp1 = 0 ;
27759 int res1 = 0 ;
27760 void *argp2 = 0 ;
27761 int res2 = 0 ;
27762 PyObject * obj0 = 0 ;
27763 PyObject * obj1 = 0 ;
27764 char * kwnames[] = {
27765 (char *) "self",(char *) "diff", NULL
27766 };
27767
27768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27770 if (!SWIG_IsOK(res1)) {
27771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27772 }
27773 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27774 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27775 if (!SWIG_IsOK(res2)) {
27776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27777 }
27778 if (!argp2) {
27779 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27780 }
27781 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 {
27785 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27786 result = (wxTimeSpan *) &_result_ref;
27787 }
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27799 PyObject *resultobj = 0;
27800 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27801 int arg2 ;
27802 wxTimeSpan *result = 0 ;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 int val2 ;
27806 int ecode2 = 0 ;
27807 PyObject * obj0 = 0 ;
27808 PyObject * obj1 = 0 ;
27809 char * kwnames[] = {
27810 (char *) "self",(char *) "n", NULL
27811 };
27812
27813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27815 if (!SWIG_IsOK(res1)) {
27816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27817 }
27818 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27819 ecode2 = SWIG_AsVal_int(obj1, &val2);
27820 if (!SWIG_IsOK(ecode2)) {
27821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27822 }
27823 arg2 = static_cast< int >(val2);
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 {
27827 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27828 result = (wxTimeSpan *) &_result_ref;
27829 }
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27834 return resultobj;
27835 fail:
27836 return NULL;
27837 }
27838
27839
27840 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27841 PyObject *resultobj = 0;
27842 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27843 wxTimeSpan *result = 0 ;
27844 void *argp1 = 0 ;
27845 int res1 = 0 ;
27846 PyObject *swig_obj[1] ;
27847
27848 if (!args) SWIG_fail;
27849 swig_obj[0] = args;
27850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27853 }
27854 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 {
27858 wxTimeSpan &_result_ref = (arg1)->Neg();
27859 result = (wxTimeSpan *) &_result_ref;
27860 }
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27872 PyObject *resultobj = 0;
27873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27874 wxTimeSpan result;
27875 void *argp1 = 0 ;
27876 int res1 = 0 ;
27877 PyObject *swig_obj[1] ;
27878
27879 if (!args) SWIG_fail;
27880 swig_obj[0] = args;
27881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27882 if (!SWIG_IsOK(res1)) {
27883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27884 }
27885 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = ((wxTimeSpan const *)arg1)->Abs();
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27900 PyObject *resultobj = 0;
27901 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27902 wxTimeSpan *arg2 = 0 ;
27903 wxTimeSpan *result = 0 ;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 void *argp2 = 0 ;
27907 int res2 = 0 ;
27908 PyObject * obj0 = 0 ;
27909 PyObject * obj1 = 0 ;
27910 char * kwnames[] = {
27911 (char *) "self",(char *) "diff", NULL
27912 };
27913
27914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27916 if (!SWIG_IsOK(res1)) {
27917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27918 }
27919 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27921 if (!SWIG_IsOK(res2)) {
27922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27923 }
27924 if (!argp2) {
27925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27926 }
27927 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 {
27931 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27932 result = (wxTimeSpan *) &_result_ref;
27933 }
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27947 wxTimeSpan *arg2 = 0 ;
27948 wxTimeSpan *result = 0 ;
27949 void *argp1 = 0 ;
27950 int res1 = 0 ;
27951 void *argp2 = 0 ;
27952 int res2 = 0 ;
27953 PyObject * obj0 = 0 ;
27954 PyObject * obj1 = 0 ;
27955 char * kwnames[] = {
27956 (char *) "self",(char *) "diff", NULL
27957 };
27958
27959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27961 if (!SWIG_IsOK(res1)) {
27962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27963 }
27964 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27966 if (!SWIG_IsOK(res2)) {
27967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27968 }
27969 if (!argp2) {
27970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27971 }
27972 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 {
27976 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27977 result = (wxTimeSpan *) &_result_ref;
27978 }
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj = 0;
27991 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27992 int arg2 ;
27993 wxTimeSpan *result = 0 ;
27994 void *argp1 = 0 ;
27995 int res1 = 0 ;
27996 int val2 ;
27997 int ecode2 = 0 ;
27998 PyObject * obj0 = 0 ;
27999 PyObject * obj1 = 0 ;
28000 char * kwnames[] = {
28001 (char *) "self",(char *) "n", NULL
28002 };
28003
28004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28006 if (!SWIG_IsOK(res1)) {
28007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28008 }
28009 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28010 ecode2 = SWIG_AsVal_int(obj1, &val2);
28011 if (!SWIG_IsOK(ecode2)) {
28012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28013 }
28014 arg2 = static_cast< int >(val2);
28015 {
28016 PyThreadState* __tstate = wxPyBeginAllowThreads();
28017 {
28018 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28019 result = (wxTimeSpan *) &_result_ref;
28020 }
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28032 PyObject *resultobj = 0;
28033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28034 wxTimeSpan *result = 0 ;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 PyObject *swig_obj[1] ;
28038
28039 if (!args) SWIG_fail;
28040 swig_obj[0] = args;
28041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28042 if (!SWIG_IsOK(res1)) {
28043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28044 }
28045 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 {
28049 wxTimeSpan &_result_ref = (arg1)->operator -();
28050 result = (wxTimeSpan *) &_result_ref;
28051 }
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28056 return resultobj;
28057 fail:
28058 return NULL;
28059 }
28060
28061
28062 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28063 PyObject *resultobj = 0;
28064 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28065 wxTimeSpan *arg2 = 0 ;
28066 wxTimeSpan result;
28067 void *argp1 = 0 ;
28068 int res1 = 0 ;
28069 void *argp2 = 0 ;
28070 int res2 = 0 ;
28071 PyObject * obj0 = 0 ;
28072 PyObject * obj1 = 0 ;
28073 char * kwnames[] = {
28074 (char *) "self",(char *) "other", NULL
28075 };
28076
28077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28079 if (!SWIG_IsOK(res1)) {
28080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28081 }
28082 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28084 if (!SWIG_IsOK(res2)) {
28085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28086 }
28087 if (!argp2) {
28088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28089 }
28090 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28091 {
28092 PyThreadState* __tstate = wxPyBeginAllowThreads();
28093 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj = 0;
28106 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28107 wxTimeSpan *arg2 = 0 ;
28108 wxTimeSpan result;
28109 void *argp1 = 0 ;
28110 int res1 = 0 ;
28111 void *argp2 = 0 ;
28112 int res2 = 0 ;
28113 PyObject * obj0 = 0 ;
28114 PyObject * obj1 = 0 ;
28115 char * kwnames[] = {
28116 (char *) "self",(char *) "other", NULL
28117 };
28118
28119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28121 if (!SWIG_IsOK(res1)) {
28122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28123 }
28124 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28125 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28126 if (!SWIG_IsOK(res2)) {
28127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28128 }
28129 if (!argp2) {
28130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28131 }
28132 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj = 0;
28148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28149 int arg2 ;
28150 wxTimeSpan result;
28151 void *argp1 = 0 ;
28152 int res1 = 0 ;
28153 int val2 ;
28154 int ecode2 = 0 ;
28155 PyObject * obj0 = 0 ;
28156 PyObject * obj1 = 0 ;
28157 char * kwnames[] = {
28158 (char *) "self",(char *) "n", NULL
28159 };
28160
28161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28163 if (!SWIG_IsOK(res1)) {
28164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28165 }
28166 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28167 ecode2 = SWIG_AsVal_int(obj1, &val2);
28168 if (!SWIG_IsOK(ecode2)) {
28169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28170 }
28171 arg2 = static_cast< int >(val2);
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = wxTimeSpan___mul__(arg1,arg2);
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj = 0;
28187 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28188 int arg2 ;
28189 wxTimeSpan result;
28190 void *argp1 = 0 ;
28191 int res1 = 0 ;
28192 int val2 ;
28193 int ecode2 = 0 ;
28194 PyObject * obj0 = 0 ;
28195 PyObject * obj1 = 0 ;
28196 char * kwnames[] = {
28197 (char *) "self",(char *) "n", NULL
28198 };
28199
28200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28202 if (!SWIG_IsOK(res1)) {
28203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28204 }
28205 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28206 ecode2 = SWIG_AsVal_int(obj1, &val2);
28207 if (!SWIG_IsOK(ecode2)) {
28208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28209 }
28210 arg2 = static_cast< int >(val2);
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = wxTimeSpan___rmul__(arg1,arg2);
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj = 0;
28226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28227 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28228 bool result;
28229 void *argp1 = 0 ;
28230 int res1 = 0 ;
28231 void *argp2 = 0 ;
28232 int res2 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "self",(char *) "other", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28241 if (!SWIG_IsOK(res1)) {
28242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28243 }
28244 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28246 if (!SWIG_IsOK(res2)) {
28247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28248 }
28249 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 {
28257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28258 }
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28266 PyObject *resultobj = 0;
28267 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28268 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28269 bool result;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 void *argp2 = 0 ;
28273 int res2 = 0 ;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char * kwnames[] = {
28277 (char *) "self",(char *) "other", NULL
28278 };
28279
28280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28282 if (!SWIG_IsOK(res1)) {
28283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28284 }
28285 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28287 if (!SWIG_IsOK(res2)) {
28288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28289 }
28290 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 {
28298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28299 }
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28307 PyObject *resultobj = 0;
28308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28309 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28310 bool result;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 void *argp2 = 0 ;
28314 int res2 = 0 ;
28315 PyObject * obj0 = 0 ;
28316 PyObject * obj1 = 0 ;
28317 char * kwnames[] = {
28318 (char *) "self",(char *) "other", NULL
28319 };
28320
28321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28323 if (!SWIG_IsOK(res1)) {
28324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28325 }
28326 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28328 if (!SWIG_IsOK(res2)) {
28329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28330 }
28331 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28332 {
28333 PyThreadState* __tstate = wxPyBeginAllowThreads();
28334 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 {
28339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28340 }
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28350 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28351 bool result;
28352 void *argp1 = 0 ;
28353 int res1 = 0 ;
28354 void *argp2 = 0 ;
28355 int res2 = 0 ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char * kwnames[] = {
28359 (char *) "self",(char *) "other", NULL
28360 };
28361
28362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28366 }
28367 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28368 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28369 if (!SWIG_IsOK(res2)) {
28370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28371 }
28372 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj = 0;
28390 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28391 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28392 bool result;
28393 void *argp1 = 0 ;
28394 int res1 = 0 ;
28395 void *argp2 = 0 ;
28396 int res2 = 0 ;
28397 PyObject * obj0 = 0 ;
28398 PyObject * obj1 = 0 ;
28399 char * kwnames[] = {
28400 (char *) "self",(char *) "other", NULL
28401 };
28402
28403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28405 if (!SWIG_IsOK(res1)) {
28406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28407 }
28408 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28410 if (!SWIG_IsOK(res2)) {
28411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28412 }
28413 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 {
28421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28422 }
28423 return resultobj;
28424 fail:
28425 return NULL;
28426 }
28427
28428
28429 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28430 PyObject *resultobj = 0;
28431 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28432 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28433 bool result;
28434 void *argp1 = 0 ;
28435 int res1 = 0 ;
28436 void *argp2 = 0 ;
28437 int res2 = 0 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "self",(char *) "other", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28448 }
28449 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28451 if (!SWIG_IsOK(res2)) {
28452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28453 }
28454 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28455 {
28456 PyThreadState* __tstate = wxPyBeginAllowThreads();
28457 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 {
28462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28471 PyObject *resultobj = 0;
28472 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28473 bool result;
28474 void *argp1 = 0 ;
28475 int res1 = 0 ;
28476 PyObject *swig_obj[1] ;
28477
28478 if (!args) SWIG_fail;
28479 swig_obj[0] = args;
28480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28481 if (!SWIG_IsOK(res1)) {
28482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28483 }
28484 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 {
28492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 PyObject *resultobj = 0;
28502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28503 bool result;
28504 void *argp1 = 0 ;
28505 int res1 = 0 ;
28506 PyObject *swig_obj[1] ;
28507
28508 if (!args) SWIG_fail;
28509 swig_obj[0] = args;
28510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28511 if (!SWIG_IsOK(res1)) {
28512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28513 }
28514 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 {
28522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28523 }
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *resultobj = 0;
28532 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28533 bool result;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 PyObject *swig_obj[1] ;
28537
28538 if (!args) SWIG_fail;
28539 swig_obj[0] = args;
28540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28543 }
28544 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 {
28552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28553 }
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28561 PyObject *resultobj = 0;
28562 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28563 wxTimeSpan *arg2 = 0 ;
28564 bool result;
28565 void *argp1 = 0 ;
28566 int res1 = 0 ;
28567 void *argp2 = 0 ;
28568 int res2 = 0 ;
28569 PyObject * obj0 = 0 ;
28570 PyObject * obj1 = 0 ;
28571 char * kwnames[] = {
28572 (char *) "self",(char *) "ts", NULL
28573 };
28574
28575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28577 if (!SWIG_IsOK(res1)) {
28578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28579 }
28580 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28582 if (!SWIG_IsOK(res2)) {
28583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28584 }
28585 if (!argp2) {
28586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28587 }
28588 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 {
28596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28597 }
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28605 PyObject *resultobj = 0;
28606 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28607 wxTimeSpan *arg2 = 0 ;
28608 bool result;
28609 void *argp1 = 0 ;
28610 int res1 = 0 ;
28611 void *argp2 = 0 ;
28612 int res2 = 0 ;
28613 PyObject * obj0 = 0 ;
28614 PyObject * obj1 = 0 ;
28615 char * kwnames[] = {
28616 (char *) "self",(char *) "ts", NULL
28617 };
28618
28619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28621 if (!SWIG_IsOK(res1)) {
28622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28623 }
28624 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28626 if (!SWIG_IsOK(res2)) {
28627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28628 }
28629 if (!argp2) {
28630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28631 }
28632 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 {
28640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28641 }
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj = 0;
28650 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28651 wxTimeSpan *arg2 = 0 ;
28652 bool result;
28653 void *argp1 = 0 ;
28654 int res1 = 0 ;
28655 void *argp2 = 0 ;
28656 int res2 = 0 ;
28657 PyObject * obj0 = 0 ;
28658 PyObject * obj1 = 0 ;
28659 char * kwnames[] = {
28660 (char *) "self",(char *) "t", NULL
28661 };
28662
28663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28665 if (!SWIG_IsOK(res1)) {
28666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28667 }
28668 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28669 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28670 if (!SWIG_IsOK(res2)) {
28671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28672 }
28673 if (!argp2) {
28674 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28675 }
28676 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28680 wxPyEndAllowThreads(__tstate);
28681 if (PyErr_Occurred()) SWIG_fail;
28682 }
28683 {
28684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28685 }
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28695 int result;
28696 void *argp1 = 0 ;
28697 int res1 = 0 ;
28698 PyObject *swig_obj[1] ;
28699
28700 if (!args) SWIG_fail;
28701 swig_obj[0] = args;
28702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28703 if (!SWIG_IsOK(res1)) {
28704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28705 }
28706 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_From_int(static_cast< int >(result));
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28721 PyObject *resultobj = 0;
28722 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28723 int result;
28724 void *argp1 = 0 ;
28725 int res1 = 0 ;
28726 PyObject *swig_obj[1] ;
28727
28728 if (!args) SWIG_fail;
28729 swig_obj[0] = args;
28730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28731 if (!SWIG_IsOK(res1)) {
28732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28733 }
28734 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_From_int(static_cast< int >(result));
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28751 int result;
28752 void *argp1 = 0 ;
28753 int res1 = 0 ;
28754 PyObject *swig_obj[1] ;
28755
28756 if (!args) SWIG_fail;
28757 swig_obj[0] = args;
28758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28759 if (!SWIG_IsOK(res1)) {
28760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28761 }
28762 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_From_int(static_cast< int >(result));
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28779 int result;
28780 void *argp1 = 0 ;
28781 int res1 = 0 ;
28782 PyObject *swig_obj[1] ;
28783
28784 if (!args) SWIG_fail;
28785 swig_obj[0] = args;
28786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28789 }
28790 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 resultobj = SWIG_From_int(static_cast< int >(result));
28798 return resultobj;
28799 fail:
28800 return NULL;
28801 }
28802
28803
28804 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28805 PyObject *resultobj = 0;
28806 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28807 wxLongLong result;
28808 void *argp1 = 0 ;
28809 int res1 = 0 ;
28810 PyObject *swig_obj[1] ;
28811
28812 if (!args) SWIG_fail;
28813 swig_obj[0] = args;
28814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28815 if (!SWIG_IsOK(res1)) {
28816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28817 }
28818 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 {
28826 PyObject *hi, *lo, *shifter, *shifted;
28827 hi = PyLong_FromLong( (&result)->GetHi() );
28828 lo = PyLong_FromLong( (&result)->GetLo() );
28829 shifter = PyLong_FromLong(32);
28830 shifted = PyNumber_Lshift(hi, shifter);
28831 resultobj = PyNumber_Or(shifted, lo);
28832 Py_DECREF(hi);
28833 Py_DECREF(lo);
28834 Py_DECREF(shifter);
28835 Py_DECREF(shifted);
28836 }
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28844 PyObject *resultobj = 0;
28845 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28846 wxLongLong result;
28847 void *argp1 = 0 ;
28848 int res1 = 0 ;
28849 PyObject *swig_obj[1] ;
28850
28851 if (!args) SWIG_fail;
28852 swig_obj[0] = args;
28853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28854 if (!SWIG_IsOK(res1)) {
28855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28856 }
28857 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 {
28865 PyObject *hi, *lo, *shifter, *shifted;
28866 hi = PyLong_FromLong( (&result)->GetHi() );
28867 lo = PyLong_FromLong( (&result)->GetLo() );
28868 shifter = PyLong_FromLong(32);
28869 shifted = PyNumber_Lshift(hi, shifter);
28870 resultobj = PyNumber_Or(shifted, lo);
28871 Py_DECREF(hi);
28872 Py_DECREF(lo);
28873 Py_DECREF(shifter);
28874 Py_DECREF(shifted);
28875 }
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28885 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28886 wxString *arg2 = (wxString *) &arg2_defvalue ;
28887 wxString result;
28888 void *argp1 = 0 ;
28889 int res1 = 0 ;
28890 bool temp2 = false ;
28891 PyObject * obj0 = 0 ;
28892 PyObject * obj1 = 0 ;
28893 char * kwnames[] = {
28894 (char *) "self",(char *) "format", NULL
28895 };
28896
28897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28899 if (!SWIG_IsOK(res1)) {
28900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28901 }
28902 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28903 if (obj1) {
28904 {
28905 arg2 = wxString_in_helper(obj1);
28906 if (arg2 == NULL) SWIG_fail;
28907 temp2 = true;
28908 }
28909 }
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 {
28917 #if wxUSE_UNICODE
28918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28919 #else
28920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28921 #endif
28922 }
28923 {
28924 if (temp2)
28925 delete arg2;
28926 }
28927 return resultobj;
28928 fail:
28929 {
28930 if (temp2)
28931 delete arg2;
28932 }
28933 return NULL;
28934 }
28935
28936
28937 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28938 PyObject *obj;
28939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28940 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28941 return SWIG_Py_Void();
28942 }
28943
28944 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28945 return SWIG_Python_InitShadowInstance(args);
28946 }
28947
28948 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28949 PyObject *resultobj = 0;
28950 int arg1 = (int) 0 ;
28951 int arg2 = (int) 0 ;
28952 int arg3 = (int) 0 ;
28953 int arg4 = (int) 0 ;
28954 wxDateSpan *result = 0 ;
28955 int val1 ;
28956 int ecode1 = 0 ;
28957 int val2 ;
28958 int ecode2 = 0 ;
28959 int val3 ;
28960 int ecode3 = 0 ;
28961 int val4 ;
28962 int ecode4 = 0 ;
28963 PyObject * obj0 = 0 ;
28964 PyObject * obj1 = 0 ;
28965 PyObject * obj2 = 0 ;
28966 PyObject * obj3 = 0 ;
28967 char * kwnames[] = {
28968 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28969 };
28970
28971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28972 if (obj0) {
28973 ecode1 = SWIG_AsVal_int(obj0, &val1);
28974 if (!SWIG_IsOK(ecode1)) {
28975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28976 }
28977 arg1 = static_cast< int >(val1);
28978 }
28979 if (obj1) {
28980 ecode2 = SWIG_AsVal_int(obj1, &val2);
28981 if (!SWIG_IsOK(ecode2)) {
28982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28983 }
28984 arg2 = static_cast< int >(val2);
28985 }
28986 if (obj2) {
28987 ecode3 = SWIG_AsVal_int(obj2, &val3);
28988 if (!SWIG_IsOK(ecode3)) {
28989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28990 }
28991 arg3 = static_cast< int >(val3);
28992 }
28993 if (obj3) {
28994 ecode4 = SWIG_AsVal_int(obj3, &val4);
28995 if (!SWIG_IsOK(ecode4)) {
28996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28997 }
28998 arg4 = static_cast< int >(val4);
28999 }
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29014 PyObject *resultobj = 0;
29015 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29016 void *argp1 = 0 ;
29017 int res1 = 0 ;
29018 PyObject *swig_obj[1] ;
29019
29020 if (!args) SWIG_fail;
29021 swig_obj[0] = args;
29022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29023 if (!SWIG_IsOK(res1)) {
29024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29025 }
29026 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29027 {
29028 PyThreadState* __tstate = wxPyBeginAllowThreads();
29029 delete arg1;
29030
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 resultobj = SWIG_Py_Void();
29035 return resultobj;
29036 fail:
29037 return NULL;
29038 }
29039
29040
29041 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29042 PyObject *resultobj = 0;
29043 int arg1 ;
29044 wxDateSpan result;
29045 int val1 ;
29046 int ecode1 = 0 ;
29047 PyObject * obj0 = 0 ;
29048 char * kwnames[] = {
29049 (char *) "days", NULL
29050 };
29051
29052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29053 ecode1 = SWIG_AsVal_int(obj0, &val1);
29054 if (!SWIG_IsOK(ecode1)) {
29055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29056 }
29057 arg1 = static_cast< int >(val1);
29058 {
29059 PyThreadState* __tstate = wxPyBeginAllowThreads();
29060 result = wxDateSpan::Days(arg1);
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29072 PyObject *resultobj = 0;
29073 wxDateSpan result;
29074
29075 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 result = wxDateSpan::Day();
29079 wxPyEndAllowThreads(__tstate);
29080 if (PyErr_Occurred()) SWIG_fail;
29081 }
29082 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29083 return resultobj;
29084 fail:
29085 return NULL;
29086 }
29087
29088
29089 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29090 PyObject *resultobj = 0;
29091 int arg1 ;
29092 wxDateSpan result;
29093 int val1 ;
29094 int ecode1 = 0 ;
29095 PyObject * obj0 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "weeks", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29101 ecode1 = SWIG_AsVal_int(obj0, &val1);
29102 if (!SWIG_IsOK(ecode1)) {
29103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29104 }
29105 arg1 = static_cast< int >(val1);
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = wxDateSpan::Weeks(arg1);
29109 wxPyEndAllowThreads(__tstate);
29110 if (PyErr_Occurred()) SWIG_fail;
29111 }
29112 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29113 return resultobj;
29114 fail:
29115 return NULL;
29116 }
29117
29118
29119 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29120 PyObject *resultobj = 0;
29121 wxDateSpan result;
29122
29123 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 result = wxDateSpan::Week();
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 int arg1 ;
29140 wxDateSpan result;
29141 int val1 ;
29142 int ecode1 = 0 ;
29143 PyObject * obj0 = 0 ;
29144 char * kwnames[] = {
29145 (char *) "mon", NULL
29146 };
29147
29148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29149 ecode1 = SWIG_AsVal_int(obj0, &val1);
29150 if (!SWIG_IsOK(ecode1)) {
29151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29152 }
29153 arg1 = static_cast< int >(val1);
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 result = wxDateSpan::Months(arg1);
29157 wxPyEndAllowThreads(__tstate);
29158 if (PyErr_Occurred()) SWIG_fail;
29159 }
29160 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 PyObject *resultobj = 0;
29169 wxDateSpan result;
29170
29171 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = wxDateSpan::Month();
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29186 PyObject *resultobj = 0;
29187 int arg1 ;
29188 wxDateSpan result;
29189 int val1 ;
29190 int ecode1 = 0 ;
29191 PyObject * obj0 = 0 ;
29192 char * kwnames[] = {
29193 (char *) "years", NULL
29194 };
29195
29196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29197 ecode1 = SWIG_AsVal_int(obj0, &val1);
29198 if (!SWIG_IsOK(ecode1)) {
29199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29200 }
29201 arg1 = static_cast< int >(val1);
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = wxDateSpan::Years(arg1);
29205 wxPyEndAllowThreads(__tstate);
29206 if (PyErr_Occurred()) SWIG_fail;
29207 }
29208 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29216 PyObject *resultobj = 0;
29217 wxDateSpan result;
29218
29219 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = wxDateSpan::Year();
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29234 PyObject *resultobj = 0;
29235 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29236 int arg2 ;
29237 wxDateSpan *result = 0 ;
29238 void *argp1 = 0 ;
29239 int res1 = 0 ;
29240 int val2 ;
29241 int ecode2 = 0 ;
29242 PyObject * obj0 = 0 ;
29243 PyObject * obj1 = 0 ;
29244 char * kwnames[] = {
29245 (char *) "self",(char *) "n", NULL
29246 };
29247
29248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29250 if (!SWIG_IsOK(res1)) {
29251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29252 }
29253 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29254 ecode2 = SWIG_AsVal_int(obj1, &val2);
29255 if (!SWIG_IsOK(ecode2)) {
29256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29257 }
29258 arg2 = static_cast< int >(val2);
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 {
29262 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29263 result = (wxDateSpan *) &_result_ref;
29264 }
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29269 return resultobj;
29270 fail:
29271 return NULL;
29272 }
29273
29274
29275 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29276 PyObject *resultobj = 0;
29277 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29278 int arg2 ;
29279 wxDateSpan *result = 0 ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 int val2 ;
29283 int ecode2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "n", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29294 }
29295 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29296 ecode2 = SWIG_AsVal_int(obj1, &val2);
29297 if (!SWIG_IsOK(ecode2)) {
29298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29299 }
29300 arg2 = static_cast< int >(val2);
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 {
29304 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29305 result = (wxDateSpan *) &_result_ref;
29306 }
29307 wxPyEndAllowThreads(__tstate);
29308 if (PyErr_Occurred()) SWIG_fail;
29309 }
29310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29318 PyObject *resultobj = 0;
29319 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29320 int arg2 ;
29321 wxDateSpan *result = 0 ;
29322 void *argp1 = 0 ;
29323 int res1 = 0 ;
29324 int val2 ;
29325 int ecode2 = 0 ;
29326 PyObject * obj0 = 0 ;
29327 PyObject * obj1 = 0 ;
29328 char * kwnames[] = {
29329 (char *) "self",(char *) "n", NULL
29330 };
29331
29332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29336 }
29337 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29338 ecode2 = SWIG_AsVal_int(obj1, &val2);
29339 if (!SWIG_IsOK(ecode2)) {
29340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29341 }
29342 arg2 = static_cast< int >(val2);
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 {
29346 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29347 result = (wxDateSpan *) &_result_ref;
29348 }
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj = 0;
29361 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29362 int arg2 ;
29363 wxDateSpan *result = 0 ;
29364 void *argp1 = 0 ;
29365 int res1 = 0 ;
29366 int val2 ;
29367 int ecode2 = 0 ;
29368 PyObject * obj0 = 0 ;
29369 PyObject * obj1 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "self",(char *) "n", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29376 if (!SWIG_IsOK(res1)) {
29377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29378 }
29379 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29380 ecode2 = SWIG_AsVal_int(obj1, &val2);
29381 if (!SWIG_IsOK(ecode2)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29383 }
29384 arg2 = static_cast< int >(val2);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 {
29388 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29389 result = (wxDateSpan *) &_result_ref;
29390 }
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 PyObject *resultobj = 0;
29403 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29404 int result;
29405 void *argp1 = 0 ;
29406 int res1 = 0 ;
29407 PyObject *swig_obj[1] ;
29408
29409 if (!args) SWIG_fail;
29410 swig_obj[0] = args;
29411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29412 if (!SWIG_IsOK(res1)) {
29413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29414 }
29415 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = (int)((wxDateSpan const *)arg1)->GetYears();
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 resultobj = SWIG_From_int(static_cast< int >(result));
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29430 PyObject *resultobj = 0;
29431 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29432 int result;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 PyObject *swig_obj[1] ;
29436
29437 if (!args) SWIG_fail;
29438 swig_obj[0] = args;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29442 }
29443 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29447 wxPyEndAllowThreads(__tstate);
29448 if (PyErr_Occurred()) SWIG_fail;
29449 }
29450 resultobj = SWIG_From_int(static_cast< int >(result));
29451 return resultobj;
29452 fail:
29453 return NULL;
29454 }
29455
29456
29457 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29458 PyObject *resultobj = 0;
29459 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29460 int result;
29461 void *argp1 = 0 ;
29462 int res1 = 0 ;
29463 PyObject *swig_obj[1] ;
29464
29465 if (!args) SWIG_fail;
29466 swig_obj[0] = args;
29467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29468 if (!SWIG_IsOK(res1)) {
29469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29470 }
29471 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29475 wxPyEndAllowThreads(__tstate);
29476 if (PyErr_Occurred()) SWIG_fail;
29477 }
29478 resultobj = SWIG_From_int(static_cast< int >(result));
29479 return resultobj;
29480 fail:
29481 return NULL;
29482 }
29483
29484
29485 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29486 PyObject *resultobj = 0;
29487 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29488 int result;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 PyObject *swig_obj[1] ;
29492
29493 if (!args) SWIG_fail;
29494 swig_obj[0] = args;
29495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29496 if (!SWIG_IsOK(res1)) {
29497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29498 }
29499 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (int)((wxDateSpan const *)arg1)->GetDays();
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 resultobj = SWIG_From_int(static_cast< int >(result));
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 PyObject *resultobj = 0;
29515 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29516 int result;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 PyObject *swig_obj[1] ;
29520
29521 if (!args) SWIG_fail;
29522 swig_obj[0] = args;
29523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29524 if (!SWIG_IsOK(res1)) {
29525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29526 }
29527 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 resultobj = SWIG_From_int(static_cast< int >(result));
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj = 0;
29543 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29544 wxDateSpan *arg2 = 0 ;
29545 wxDateSpan *result = 0 ;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 void *argp2 = 0 ;
29549 int res2 = 0 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char * kwnames[] = {
29553 (char *) "self",(char *) "other", NULL
29554 };
29555
29556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29558 if (!SWIG_IsOK(res1)) {
29559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29560 }
29561 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29563 if (!SWIG_IsOK(res2)) {
29564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29565 }
29566 if (!argp2) {
29567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29568 }
29569 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 {
29573 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29574 result = (wxDateSpan *) &_result_ref;
29575 }
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29580 return resultobj;
29581 fail:
29582 return NULL;
29583 }
29584
29585
29586 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29587 PyObject *resultobj = 0;
29588 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29589 wxDateSpan *arg2 = 0 ;
29590 wxDateSpan *result = 0 ;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 void *argp2 = 0 ;
29594 int res2 = 0 ;
29595 PyObject * obj0 = 0 ;
29596 PyObject * obj1 = 0 ;
29597 char * kwnames[] = {
29598 (char *) "self",(char *) "other", NULL
29599 };
29600
29601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29605 }
29606 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29608 if (!SWIG_IsOK(res2)) {
29609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29610 }
29611 if (!argp2) {
29612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29613 }
29614 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 {
29618 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29619 result = (wxDateSpan *) &_result_ref;
29620 }
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29632 PyObject *resultobj = 0;
29633 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29634 wxDateSpan *result = 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 PyObject *swig_obj[1] ;
29638
29639 if (!args) SWIG_fail;
29640 swig_obj[0] = args;
29641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29642 if (!SWIG_IsOK(res1)) {
29643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29644 }
29645 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 {
29649 wxDateSpan &_result_ref = (arg1)->Neg();
29650 result = (wxDateSpan *) &_result_ref;
29651 }
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj = 0;
29664 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29665 int arg2 ;
29666 wxDateSpan *result = 0 ;
29667 void *argp1 = 0 ;
29668 int res1 = 0 ;
29669 int val2 ;
29670 int ecode2 = 0 ;
29671 PyObject * obj0 = 0 ;
29672 PyObject * obj1 = 0 ;
29673 char * kwnames[] = {
29674 (char *) "self",(char *) "factor", NULL
29675 };
29676
29677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29679 if (!SWIG_IsOK(res1)) {
29680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29681 }
29682 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29683 ecode2 = SWIG_AsVal_int(obj1, &val2);
29684 if (!SWIG_IsOK(ecode2)) {
29685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29686 }
29687 arg2 = static_cast< int >(val2);
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 {
29691 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29692 result = (wxDateSpan *) &_result_ref;
29693 }
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj = 0;
29706 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29707 wxDateSpan *arg2 = 0 ;
29708 wxDateSpan *result = 0 ;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 void *argp2 = 0 ;
29712 int res2 = 0 ;
29713 PyObject * obj0 = 0 ;
29714 PyObject * obj1 = 0 ;
29715 char * kwnames[] = {
29716 (char *) "self",(char *) "other", NULL
29717 };
29718
29719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29721 if (!SWIG_IsOK(res1)) {
29722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29723 }
29724 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29726 if (!SWIG_IsOK(res2)) {
29727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29728 }
29729 if (!argp2) {
29730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29731 }
29732 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 {
29736 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29737 result = (wxDateSpan *) &_result_ref;
29738 }
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj = 0;
29751 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29752 wxDateSpan *arg2 = 0 ;
29753 wxDateSpan *result = 0 ;
29754 void *argp1 = 0 ;
29755 int res1 = 0 ;
29756 void *argp2 = 0 ;
29757 int res2 = 0 ;
29758 PyObject * obj0 = 0 ;
29759 PyObject * obj1 = 0 ;
29760 char * kwnames[] = {
29761 (char *) "self",(char *) "other", NULL
29762 };
29763
29764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29766 if (!SWIG_IsOK(res1)) {
29767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29768 }
29769 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29771 if (!SWIG_IsOK(res2)) {
29772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29773 }
29774 if (!argp2) {
29775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29776 }
29777 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 {
29781 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29782 result = (wxDateSpan *) &_result_ref;
29783 }
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29795 PyObject *resultobj = 0;
29796 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29797 wxDateSpan *result = 0 ;
29798 void *argp1 = 0 ;
29799 int res1 = 0 ;
29800 PyObject *swig_obj[1] ;
29801
29802 if (!args) SWIG_fail;
29803 swig_obj[0] = args;
29804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29807 }
29808 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29809 {
29810 PyThreadState* __tstate = wxPyBeginAllowThreads();
29811 {
29812 wxDateSpan &_result_ref = (arg1)->operator -();
29813 result = (wxDateSpan *) &_result_ref;
29814 }
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29826 PyObject *resultobj = 0;
29827 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29828 int arg2 ;
29829 wxDateSpan *result = 0 ;
29830 void *argp1 = 0 ;
29831 int res1 = 0 ;
29832 int val2 ;
29833 int ecode2 = 0 ;
29834 PyObject * obj0 = 0 ;
29835 PyObject * obj1 = 0 ;
29836 char * kwnames[] = {
29837 (char *) "self",(char *) "factor", NULL
29838 };
29839
29840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29842 if (!SWIG_IsOK(res1)) {
29843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29844 }
29845 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29846 ecode2 = SWIG_AsVal_int(obj1, &val2);
29847 if (!SWIG_IsOK(ecode2)) {
29848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29849 }
29850 arg2 = static_cast< int >(val2);
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 {
29854 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29855 result = (wxDateSpan *) &_result_ref;
29856 }
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj = 0;
29869 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29870 wxDateSpan *arg2 = 0 ;
29871 wxDateSpan result;
29872 void *argp1 = 0 ;
29873 int res1 = 0 ;
29874 void *argp2 = 0 ;
29875 int res2 = 0 ;
29876 PyObject * obj0 = 0 ;
29877 PyObject * obj1 = 0 ;
29878 char * kwnames[] = {
29879 (char *) "self",(char *) "other", NULL
29880 };
29881
29882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29884 if (!SWIG_IsOK(res1)) {
29885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29886 }
29887 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29889 if (!SWIG_IsOK(res2)) {
29890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29891 }
29892 if (!argp2) {
29893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29894 }
29895 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj = 0;
29911 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29912 wxDateSpan *arg2 = 0 ;
29913 wxDateSpan result;
29914 void *argp1 = 0 ;
29915 int res1 = 0 ;
29916 void *argp2 = 0 ;
29917 int res2 = 0 ;
29918 PyObject * obj0 = 0 ;
29919 PyObject * obj1 = 0 ;
29920 char * kwnames[] = {
29921 (char *) "self",(char *) "other", NULL
29922 };
29923
29924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29926 if (!SWIG_IsOK(res1)) {
29927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29928 }
29929 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29931 if (!SWIG_IsOK(res2)) {
29932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29933 }
29934 if (!argp2) {
29935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29936 }
29937 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj = 0;
29953 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29954 int arg2 ;
29955 wxDateSpan result;
29956 void *argp1 = 0 ;
29957 int res1 = 0 ;
29958 int val2 ;
29959 int ecode2 = 0 ;
29960 PyObject * obj0 = 0 ;
29961 PyObject * obj1 = 0 ;
29962 char * kwnames[] = {
29963 (char *) "self",(char *) "n", NULL
29964 };
29965
29966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29968 if (!SWIG_IsOK(res1)) {
29969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29970 }
29971 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29972 ecode2 = SWIG_AsVal_int(obj1, &val2);
29973 if (!SWIG_IsOK(ecode2)) {
29974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29975 }
29976 arg2 = static_cast< int >(val2);
29977 {
29978 PyThreadState* __tstate = wxPyBeginAllowThreads();
29979 result = wxDateSpan___mul__(arg1,arg2);
29980 wxPyEndAllowThreads(__tstate);
29981 if (PyErr_Occurred()) SWIG_fail;
29982 }
29983 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj = 0;
29992 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29993 int arg2 ;
29994 wxDateSpan result;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 int val2 ;
29998 int ecode2 = 0 ;
29999 PyObject * obj0 = 0 ;
30000 PyObject * obj1 = 0 ;
30001 char * kwnames[] = {
30002 (char *) "self",(char *) "n", NULL
30003 };
30004
30005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30007 if (!SWIG_IsOK(res1)) {
30008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30009 }
30010 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30011 ecode2 = SWIG_AsVal_int(obj1, &val2);
30012 if (!SWIG_IsOK(ecode2)) {
30013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30014 }
30015 arg2 = static_cast< int >(val2);
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = wxDateSpan___rmul__(arg1,arg2);
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj = 0;
30031 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30032 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30033 bool result;
30034 void *argp1 = 0 ;
30035 int res1 = 0 ;
30036 void *argp2 = 0 ;
30037 int res2 = 0 ;
30038 PyObject * obj0 = 0 ;
30039 PyObject * obj1 = 0 ;
30040 char * kwnames[] = {
30041 (char *) "self",(char *) "other", NULL
30042 };
30043
30044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30048 }
30049 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30051 if (!SWIG_IsOK(res2)) {
30052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30053 }
30054 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj = 0;
30072 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30073 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30074 bool result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 void *argp2 = 0 ;
30078 int res2 = 0 ;
30079 PyObject * obj0 = 0 ;
30080 PyObject * obj1 = 0 ;
30081 char * kwnames[] = {
30082 (char *) "self",(char *) "other", NULL
30083 };
30084
30085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30087 if (!SWIG_IsOK(res1)) {
30088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30089 }
30090 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30092 if (!SWIG_IsOK(res2)) {
30093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30094 }
30095 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 {
30103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *obj;
30113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30114 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30115 return SWIG_Py_Void();
30116 }
30117
30118 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30119 return SWIG_Python_InitShadowInstance(args);
30120 }
30121
30122 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30123 PyObject *resultobj = 0;
30124 long result;
30125
30126 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = (long)wxGetLocalTime();
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_From_long(static_cast< long >(result));
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 long result;
30143
30144 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = (long)wxGetUTCTime();
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 resultobj = SWIG_From_long(static_cast< long >(result));
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 long result;
30161
30162 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = (long)wxGetCurrentTime();
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_From_long(static_cast< long >(result));
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30177 PyObject *resultobj = 0;
30178 wxLongLong result;
30179
30180 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = wxGetLocalTimeMillis();
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 PyObject *hi, *lo, *shifter, *shifted;
30189 hi = PyLong_FromLong( (&result)->GetHi() );
30190 lo = PyLong_FromLong( (&result)->GetLo() );
30191 shifter = PyLong_FromLong(32);
30192 shifted = PyNumber_Lshift(hi, shifter);
30193 resultobj = PyNumber_Or(shifted, lo);
30194 Py_DECREF(hi);
30195 Py_DECREF(lo);
30196 Py_DECREF(shifter);
30197 Py_DECREF(shifted);
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30206 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30207 return 1;
30208 }
30209
30210
30211 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30212 PyObject *pyobj = 0;
30213
30214 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30215 return pyobj;
30216 }
30217
30218
30219 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30220 PyObject *resultobj = 0;
30221 wxDataFormatId arg1 ;
30222 wxDataFormat *result = 0 ;
30223 int val1 ;
30224 int ecode1 = 0 ;
30225 PyObject * obj0 = 0 ;
30226 char * kwnames[] = {
30227 (char *) "type", NULL
30228 };
30229
30230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30231 ecode1 = SWIG_AsVal_int(obj0, &val1);
30232 if (!SWIG_IsOK(ecode1)) {
30233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30234 }
30235 arg1 = static_cast< wxDataFormatId >(val1);
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 result = (wxDataFormat *)new wxDataFormat(arg1);
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30250 PyObject *resultobj = 0;
30251 wxString *arg1 = 0 ;
30252 wxDataFormat *result = 0 ;
30253 bool temp1 = false ;
30254 PyObject * obj0 = 0 ;
30255 char * kwnames[] = {
30256 (char *) "format", NULL
30257 };
30258
30259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30260 {
30261 arg1 = wxString_in_helper(obj0);
30262 if (arg1 == NULL) SWIG_fail;
30263 temp1 = true;
30264 }
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30272 {
30273 if (temp1)
30274 delete arg1;
30275 }
30276 return resultobj;
30277 fail:
30278 {
30279 if (temp1)
30280 delete arg1;
30281 }
30282 return NULL;
30283 }
30284
30285
30286 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30287 PyObject *resultobj = 0;
30288 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30289 void *argp1 = 0 ;
30290 int res1 = 0 ;
30291 PyObject *swig_obj[1] ;
30292
30293 if (!args) SWIG_fail;
30294 swig_obj[0] = args;
30295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30296 if (!SWIG_IsOK(res1)) {
30297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30298 }
30299 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 delete arg1;
30303
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 resultobj = SWIG_Py_Void();
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30315 PyObject *resultobj = 0;
30316 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30317 wxDataFormatId arg2 ;
30318 bool result;
30319 void *argp1 = 0 ;
30320 int res1 = 0 ;
30321 int val2 ;
30322 int ecode2 = 0 ;
30323
30324 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30326 if (!SWIG_IsOK(res1)) {
30327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30328 }
30329 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30330 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30331 if (!SWIG_IsOK(ecode2)) {
30332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30333 }
30334 arg2 = static_cast< wxDataFormatId >(val2);
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 {
30342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30343 }
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30351 PyObject *resultobj = 0;
30352 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30353 wxDataFormatId arg2 ;
30354 bool result;
30355 void *argp1 = 0 ;
30356 int res1 = 0 ;
30357 int val2 ;
30358 int ecode2 = 0 ;
30359
30360 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30362 if (!SWIG_IsOK(res1)) {
30363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30364 }
30365 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30366 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30367 if (!SWIG_IsOK(ecode2)) {
30368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30369 }
30370 arg2 = static_cast< wxDataFormatId >(val2);
30371 {
30372 PyThreadState* __tstate = wxPyBeginAllowThreads();
30373 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30374 wxPyEndAllowThreads(__tstate);
30375 if (PyErr_Occurred()) SWIG_fail;
30376 }
30377 {
30378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30379 }
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30387 PyObject *resultobj = 0;
30388 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30389 wxDataFormat *arg2 = 0 ;
30390 bool result;
30391 void *argp1 = 0 ;
30392 int res1 = 0 ;
30393 void *argp2 = 0 ;
30394 int res2 = 0 ;
30395
30396 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30398 if (!SWIG_IsOK(res1)) {
30399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30400 }
30401 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30403 if (!SWIG_IsOK(res2)) {
30404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30405 }
30406 if (!argp2) {
30407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30408 }
30409 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 {
30417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30418 }
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30426 int argc;
30427 PyObject *argv[3];
30428
30429 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30430 --argc;
30431 if (argc == 2) {
30432 int _v = 0;
30433 {
30434 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30435 _v = SWIG_CheckState(res);
30436 }
30437 if (!_v) goto check_1;
30438 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30439 }
30440 check_1:
30441
30442 if (argc == 2) {
30443 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30444 }
30445
30446 fail:
30447 Py_INCREF(Py_NotImplemented);
30448 return Py_NotImplemented;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30453 PyObject *resultobj = 0;
30454 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30455 wxDataFormat *arg2 = 0 ;
30456 bool result;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 void *argp2 = 0 ;
30460 int res2 = 0 ;
30461
30462 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30464 if (!SWIG_IsOK(res1)) {
30465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30466 }
30467 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30469 if (!SWIG_IsOK(res2)) {
30470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30471 }
30472 if (!argp2) {
30473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30474 }
30475 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 {
30483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30484 }
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30492 int argc;
30493 PyObject *argv[3];
30494
30495 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30496 --argc;
30497 if (argc == 2) {
30498 int _v = 0;
30499 {
30500 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30501 _v = SWIG_CheckState(res);
30502 }
30503 if (!_v) goto check_1;
30504 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30505 }
30506 check_1:
30507
30508 if (argc == 2) {
30509 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30510 }
30511
30512 fail:
30513 Py_INCREF(Py_NotImplemented);
30514 return Py_NotImplemented;
30515 }
30516
30517
30518 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj = 0;
30520 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30521 wxDataFormatId arg2 ;
30522 void *argp1 = 0 ;
30523 int res1 = 0 ;
30524 int val2 ;
30525 int ecode2 = 0 ;
30526 PyObject * obj0 = 0 ;
30527 PyObject * obj1 = 0 ;
30528 char * kwnames[] = {
30529 (char *) "self",(char *) "format", NULL
30530 };
30531
30532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30534 if (!SWIG_IsOK(res1)) {
30535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30536 }
30537 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30538 ecode2 = SWIG_AsVal_int(obj1, &val2);
30539 if (!SWIG_IsOK(ecode2)) {
30540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30541 }
30542 arg2 = static_cast< wxDataFormatId >(val2);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 (arg1)->SetType(arg2);
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_Py_Void();
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30559 wxDataFormatId result;
30560 void *argp1 = 0 ;
30561 int res1 = 0 ;
30562 PyObject *swig_obj[1] ;
30563
30564 if (!args) SWIG_fail;
30565 swig_obj[0] = args;
30566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30569 }
30570 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_From_int(static_cast< int >(result));
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30585 PyObject *resultobj = 0;
30586 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30587 wxString result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30597 }
30598 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = ((wxDataFormat const *)arg1)->GetId();
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 {
30606 #if wxUSE_UNICODE
30607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30608 #else
30609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30610 #endif
30611 }
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30619 PyObject *resultobj = 0;
30620 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30621 wxString *arg2 = 0 ;
30622 void *argp1 = 0 ;
30623 int res1 = 0 ;
30624 bool temp2 = false ;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627 char * kwnames[] = {
30628 (char *) "self",(char *) "format", NULL
30629 };
30630
30631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30635 }
30636 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30637 {
30638 arg2 = wxString_in_helper(obj1);
30639 if (arg2 == NULL) SWIG_fail;
30640 temp2 = true;
30641 }
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 (arg1)->SetId((wxString const &)*arg2);
30645 wxPyEndAllowThreads(__tstate);
30646 if (PyErr_Occurred()) SWIG_fail;
30647 }
30648 resultobj = SWIG_Py_Void();
30649 {
30650 if (temp2)
30651 delete arg2;
30652 }
30653 return resultobj;
30654 fail:
30655 {
30656 if (temp2)
30657 delete arg2;
30658 }
30659 return NULL;
30660 }
30661
30662
30663 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30664 PyObject *obj;
30665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30666 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30667 return SWIG_Py_Void();
30668 }
30669
30670 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 return SWIG_Python_InitShadowInstance(args);
30672 }
30673
30674 SWIGINTERN int FormatInvalid_set(PyObject *) {
30675 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30676 return 1;
30677 }
30678
30679
30680 SWIGINTERN PyObject *FormatInvalid_get(void) {
30681 PyObject *pyobj = 0;
30682
30683 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30684 return pyobj;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxDataObject *arg1 = (wxDataObject *) 0 ;
30691 void *argp1 = 0 ;
30692 int res1 = 0 ;
30693 PyObject *swig_obj[1] ;
30694
30695 if (!args) SWIG_fail;
30696 swig_obj[0] = args;
30697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30698 if (!SWIG_IsOK(res1)) {
30699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30700 }
30701 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30702 {
30703 PyThreadState* __tstate = wxPyBeginAllowThreads();
30704 delete arg1;
30705
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_Py_Void();
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxDataObject *arg1 = (wxDataObject *) 0 ;
30719 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30720 SwigValueWrapper<wxDataFormat > result;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 int val2 ;
30724 int ecode2 = 0 ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 char * kwnames[] = {
30728 (char *) "self",(char *) "dir", NULL
30729 };
30730
30731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30733 if (!SWIG_IsOK(res1)) {
30734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30735 }
30736 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30737 if (obj1) {
30738 ecode2 = SWIG_AsVal_int(obj1, &val2);
30739 if (!SWIG_IsOK(ecode2)) {
30740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30741 }
30742 arg2 = static_cast< wxDataObject::Direction >(val2);
30743 }
30744 {
30745 PyThreadState* __tstate = wxPyBeginAllowThreads();
30746 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30747 wxPyEndAllowThreads(__tstate);
30748 if (PyErr_Occurred()) SWIG_fail;
30749 }
30750 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30751 return resultobj;
30752 fail:
30753 return NULL;
30754 }
30755
30756
30757 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30758 PyObject *resultobj = 0;
30759 wxDataObject *arg1 = (wxDataObject *) 0 ;
30760 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30761 size_t result;
30762 void *argp1 = 0 ;
30763 int res1 = 0 ;
30764 int val2 ;
30765 int ecode2 = 0 ;
30766 PyObject * obj0 = 0 ;
30767 PyObject * obj1 = 0 ;
30768 char * kwnames[] = {
30769 (char *) "self",(char *) "dir", NULL
30770 };
30771
30772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30778 if (obj1) {
30779 ecode2 = SWIG_AsVal_int(obj1, &val2);
30780 if (!SWIG_IsOK(ecode2)) {
30781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30782 }
30783 arg2 = static_cast< wxDataObject::Direction >(val2);
30784 }
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30788 wxPyEndAllowThreads(__tstate);
30789 if (PyErr_Occurred()) SWIG_fail;
30790 }
30791 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30792 return resultobj;
30793 fail:
30794 return NULL;
30795 }
30796
30797
30798 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30799 PyObject *resultobj = 0;
30800 wxDataObject *arg1 = (wxDataObject *) 0 ;
30801 wxDataFormat *arg2 = 0 ;
30802 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30803 bool result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 void *argp2 = 0 ;
30807 int res2 = 0 ;
30808 int val3 ;
30809 int ecode3 = 0 ;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 PyObject * obj2 = 0 ;
30813 char * kwnames[] = {
30814 (char *) "self",(char *) "format",(char *) "dir", NULL
30815 };
30816
30817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30824 if (!SWIG_IsOK(res2)) {
30825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30826 }
30827 if (!argp2) {
30828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30829 }
30830 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30831 if (obj2) {
30832 ecode3 = SWIG_AsVal_int(obj2, &val3);
30833 if (!SWIG_IsOK(ecode3)) {
30834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30835 }
30836 arg3 = static_cast< wxDataObject::Direction >(val3);
30837 }
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 {
30845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj = 0;
30855 wxDataObject *arg1 = (wxDataObject *) 0 ;
30856 wxDataFormat *arg2 = 0 ;
30857 size_t result;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 void *argp2 = 0 ;
30861 int res2 = 0 ;
30862 PyObject * obj0 = 0 ;
30863 PyObject * obj1 = 0 ;
30864 char * kwnames[] = {
30865 (char *) "self",(char *) "format", NULL
30866 };
30867
30868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30870 if (!SWIG_IsOK(res1)) {
30871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30872 }
30873 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30874 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30875 if (!SWIG_IsOK(res2)) {
30876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30877 }
30878 if (!argp2) {
30879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30880 }
30881 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30896 PyObject *resultobj = 0;
30897 wxDataObject *arg1 = (wxDataObject *) 0 ;
30898 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30899 PyObject *result = 0 ;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 int val2 ;
30903 int ecode2 = 0 ;
30904 PyObject * obj0 = 0 ;
30905 PyObject * obj1 = 0 ;
30906 char * kwnames[] = {
30907 (char *) "self",(char *) "dir", NULL
30908 };
30909
30910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30914 }
30915 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30916 if (obj1) {
30917 ecode2 = SWIG_AsVal_int(obj1, &val2);
30918 if (!SWIG_IsOK(ecode2)) {
30919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30920 }
30921 arg2 = static_cast< wxDataObject::Direction >(val2);
30922 }
30923 {
30924 PyThreadState* __tstate = wxPyBeginAllowThreads();
30925 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 resultobj = result;
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj = 0;
30938 wxDataObject *arg1 = (wxDataObject *) 0 ;
30939 wxDataFormat *arg2 = 0 ;
30940 PyObject *result = 0 ;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 void *argp2 = 0 ;
30944 int res2 = 0 ;
30945 PyObject * obj0 = 0 ;
30946 PyObject * obj1 = 0 ;
30947 char * kwnames[] = {
30948 (char *) "self",(char *) "format", NULL
30949 };
30950
30951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30955 }
30956 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30957 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30958 if (!SWIG_IsOK(res2)) {
30959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30960 }
30961 if (!argp2) {
30962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30963 }
30964 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30965 {
30966 PyThreadState* __tstate = wxPyBeginAllowThreads();
30967 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 resultobj = result;
30972 return resultobj;
30973 fail:
30974 return NULL;
30975 }
30976
30977
30978 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30979 PyObject *resultobj = 0;
30980 wxDataObject *arg1 = (wxDataObject *) 0 ;
30981 wxDataFormat *arg2 = 0 ;
30982 PyObject *arg3 = (PyObject *) 0 ;
30983 bool result;
30984 void *argp1 = 0 ;
30985 int res1 = 0 ;
30986 void *argp2 = 0 ;
30987 int res2 = 0 ;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 PyObject * obj2 = 0 ;
30991 char * kwnames[] = {
30992 (char *) "self",(char *) "format",(char *) "data", NULL
30993 };
30994
30995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30999 }
31000 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31002 if (!SWIG_IsOK(res2)) {
31003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31004 }
31005 if (!argp2) {
31006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31007 }
31008 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31009 arg3 = obj2;
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31013 wxPyEndAllowThreads(__tstate);
31014 if (PyErr_Occurred()) SWIG_fail;
31015 }
31016 {
31017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31018 }
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *obj;
31027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31028 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31029 return SWIG_Py_Void();
31030 }
31031
31032 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj = 0;
31034 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31035 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31036 wxDataObjectSimple *result = 0 ;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 PyObject * obj0 = 0 ;
31040 char * kwnames[] = {
31041 (char *) "format", NULL
31042 };
31043
31044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31045 if (obj0) {
31046 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31047 if (!SWIG_IsOK(res1)) {
31048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31049 }
31050 if (!argp1) {
31051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31052 }
31053 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31054 }
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31069 PyObject *resultobj = 0;
31070 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31071 wxDataFormat *result = 0 ;
31072 void *argp1 = 0 ;
31073 int res1 = 0 ;
31074 PyObject *swig_obj[1] ;
31075
31076 if (!args) SWIG_fail;
31077 swig_obj[0] = args;
31078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31079 if (!SWIG_IsOK(res1)) {
31080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31081 }
31082 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 {
31086 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31087 result = (wxDataFormat *) &_result_ref;
31088 }
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31102 wxDataFormat *arg2 = 0 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 void *argp2 = 0 ;
31106 int res2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "format", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31117 }
31118 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31120 if (!SWIG_IsOK(res2)) {
31121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31122 }
31123 if (!argp2) {
31124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31125 }
31126 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_Py_Void();
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31141 PyObject *resultobj = 0;
31142 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31143 size_t result;
31144 void *argp1 = 0 ;
31145 int res1 = 0 ;
31146 PyObject *swig_obj[1] ;
31147
31148 if (!args) SWIG_fail;
31149 swig_obj[0] = args;
31150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31151 if (!SWIG_IsOK(res1)) {
31152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31153 }
31154 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31169 PyObject *resultobj = 0;
31170 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31171 PyObject *result = 0 ;
31172 void *argp1 = 0 ;
31173 int res1 = 0 ;
31174 PyObject *swig_obj[1] ;
31175
31176 if (!args) SWIG_fail;
31177 swig_obj[0] = args;
31178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31181 }
31182 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = result;
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = 0;
31198 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31199 PyObject *arg2 = (PyObject *) 0 ;
31200 bool result;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 PyObject * obj0 = 0 ;
31204 PyObject * obj1 = 0 ;
31205 char * kwnames[] = {
31206 (char *) "self",(char *) "data", NULL
31207 };
31208
31209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31211 if (!SWIG_IsOK(res1)) {
31212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31213 }
31214 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31215 arg2 = obj1;
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 {
31223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31224 }
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *obj;
31233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31234 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31235 return SWIG_Py_Void();
31236 }
31237
31238 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 return SWIG_Python_InitShadowInstance(args);
31240 }
31241
31242 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31243 PyObject *resultobj = 0;
31244 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31245 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31246 wxPyDataObjectSimple *result = 0 ;
31247 void *argp1 = 0 ;
31248 int res1 = 0 ;
31249 PyObject * obj0 = 0 ;
31250 char * kwnames[] = {
31251 (char *) "format", NULL
31252 };
31253
31254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31255 if (obj0) {
31256 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31257 if (!SWIG_IsOK(res1)) {
31258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31259 }
31260 if (!argp1) {
31261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31262 }
31263 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31264 }
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31279 PyObject *resultobj = 0;
31280 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31281 PyObject *arg2 = (PyObject *) 0 ;
31282 PyObject *arg3 = (PyObject *) 0 ;
31283 void *argp1 = 0 ;
31284 int res1 = 0 ;
31285 PyObject * obj0 = 0 ;
31286 PyObject * obj1 = 0 ;
31287 PyObject * obj2 = 0 ;
31288 char * kwnames[] = {
31289 (char *) "self",(char *) "self",(char *) "_class", NULL
31290 };
31291
31292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31294 if (!SWIG_IsOK(res1)) {
31295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31296 }
31297 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31298 arg2 = obj1;
31299 arg3 = obj2;
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 (arg1)->_setCallbackInfo(arg2,arg3);
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_Py_Void();
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31314 PyObject *obj;
31315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31316 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31317 return SWIG_Py_Void();
31318 }
31319
31320 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321 return SWIG_Python_InitShadowInstance(args);
31322 }
31323
31324 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31325 PyObject *resultobj = 0;
31326 wxDataObjectComposite *result = 0 ;
31327
31328 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj = 0;
31344 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31345 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31346 bool arg3 = (bool) false ;
31347 void *argp1 = 0 ;
31348 int res1 = 0 ;
31349 int res2 = 0 ;
31350 bool val3 ;
31351 int ecode3 = 0 ;
31352 PyObject * obj0 = 0 ;
31353 PyObject * obj1 = 0 ;
31354 PyObject * obj2 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31363 }
31364 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31365 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31366 if (!SWIG_IsOK(res2)) {
31367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31368 }
31369 if (obj2) {
31370 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31371 if (!SWIG_IsOK(ecode3)) {
31372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31373 }
31374 arg3 = static_cast< bool >(val3);
31375 }
31376 {
31377 PyThreadState* __tstate = wxPyBeginAllowThreads();
31378 (arg1)->Add(arg2,arg3);
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 resultobj = SWIG_Py_Void();
31383 return resultobj;
31384 fail:
31385 return NULL;
31386 }
31387
31388
31389 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31390 PyObject *resultobj = 0;
31391 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31392 SwigValueWrapper<wxDataFormat > result;
31393 void *argp1 = 0 ;
31394 int res1 = 0 ;
31395 PyObject *swig_obj[1] ;
31396
31397 if (!args) SWIG_fail;
31398 swig_obj[0] = args;
31399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31400 if (!SWIG_IsOK(res1)) {
31401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31402 }
31403 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31418 PyObject *obj;
31419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31420 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31421 return SWIG_Py_Void();
31422 }
31423
31424 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31425 return SWIG_Python_InitShadowInstance(args);
31426 }
31427
31428 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj = 0;
31430 wxString const &arg1_defvalue = wxPyEmptyString ;
31431 wxString *arg1 = (wxString *) &arg1_defvalue ;
31432 wxTextDataObject *result = 0 ;
31433 bool temp1 = false ;
31434 PyObject * obj0 = 0 ;
31435 char * kwnames[] = {
31436 (char *) "text", NULL
31437 };
31438
31439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31440 if (obj0) {
31441 {
31442 arg1 = wxString_in_helper(obj0);
31443 if (arg1 == NULL) SWIG_fail;
31444 temp1 = true;
31445 }
31446 }
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31454 {
31455 if (temp1)
31456 delete arg1;
31457 }
31458 return resultobj;
31459 fail:
31460 {
31461 if (temp1)
31462 delete arg1;
31463 }
31464 return NULL;
31465 }
31466
31467
31468 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31469 PyObject *resultobj = 0;
31470 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31471 size_t result;
31472 void *argp1 = 0 ;
31473 int res1 = 0 ;
31474 PyObject *swig_obj[1] ;
31475
31476 if (!args) SWIG_fail;
31477 swig_obj[0] = args;
31478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31479 if (!SWIG_IsOK(res1)) {
31480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31481 }
31482 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 result = (size_t)(arg1)->GetTextLength();
31486 wxPyEndAllowThreads(__tstate);
31487 if (PyErr_Occurred()) SWIG_fail;
31488 }
31489 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31497 PyObject *resultobj = 0;
31498 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31499 wxString result;
31500 void *argp1 = 0 ;
31501 int res1 = 0 ;
31502 PyObject *swig_obj[1] ;
31503
31504 if (!args) SWIG_fail;
31505 swig_obj[0] = args;
31506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31507 if (!SWIG_IsOK(res1)) {
31508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31509 }
31510 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31511 {
31512 PyThreadState* __tstate = wxPyBeginAllowThreads();
31513 result = (arg1)->GetText();
31514 wxPyEndAllowThreads(__tstate);
31515 if (PyErr_Occurred()) SWIG_fail;
31516 }
31517 {
31518 #if wxUSE_UNICODE
31519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31520 #else
31521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31522 #endif
31523 }
31524 return resultobj;
31525 fail:
31526 return NULL;
31527 }
31528
31529
31530 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31531 PyObject *resultobj = 0;
31532 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31533 wxString *arg2 = 0 ;
31534 void *argp1 = 0 ;
31535 int res1 = 0 ;
31536 bool temp2 = false ;
31537 PyObject * obj0 = 0 ;
31538 PyObject * obj1 = 0 ;
31539 char * kwnames[] = {
31540 (char *) "self",(char *) "text", NULL
31541 };
31542
31543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31545 if (!SWIG_IsOK(res1)) {
31546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31547 }
31548 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31549 {
31550 arg2 = wxString_in_helper(obj1);
31551 if (arg2 == NULL) SWIG_fail;
31552 temp2 = true;
31553 }
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 (arg1)->SetText((wxString const &)*arg2);
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 resultobj = SWIG_Py_Void();
31561 {
31562 if (temp2)
31563 delete arg2;
31564 }
31565 return resultobj;
31566 fail:
31567 {
31568 if (temp2)
31569 delete arg2;
31570 }
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 PyObject *obj;
31577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31578 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31579 return SWIG_Py_Void();
31580 }
31581
31582 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 return SWIG_Python_InitShadowInstance(args);
31584 }
31585
31586 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj = 0;
31588 wxString const &arg1_defvalue = wxPyEmptyString ;
31589 wxString *arg1 = (wxString *) &arg1_defvalue ;
31590 wxPyTextDataObject *result = 0 ;
31591 bool temp1 = false ;
31592 PyObject * obj0 = 0 ;
31593 char * kwnames[] = {
31594 (char *) "text", NULL
31595 };
31596
31597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31598 if (obj0) {
31599 {
31600 arg1 = wxString_in_helper(obj0);
31601 if (arg1 == NULL) SWIG_fail;
31602 temp1 = true;
31603 }
31604 }
31605 {
31606 PyThreadState* __tstate = wxPyBeginAllowThreads();
31607 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31612 {
31613 if (temp1)
31614 delete arg1;
31615 }
31616 return resultobj;
31617 fail:
31618 {
31619 if (temp1)
31620 delete arg1;
31621 }
31622 return NULL;
31623 }
31624
31625
31626 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj = 0;
31628 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31629 PyObject *arg2 = (PyObject *) 0 ;
31630 PyObject *arg3 = (PyObject *) 0 ;
31631 void *argp1 = 0 ;
31632 int res1 = 0 ;
31633 PyObject * obj0 = 0 ;
31634 PyObject * obj1 = 0 ;
31635 PyObject * obj2 = 0 ;
31636 char * kwnames[] = {
31637 (char *) "self",(char *) "self",(char *) "_class", NULL
31638 };
31639
31640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31642 if (!SWIG_IsOK(res1)) {
31643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31644 }
31645 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31646 arg2 = obj1;
31647 arg3 = obj2;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 (arg1)->_setCallbackInfo(arg2,arg3);
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_Py_Void();
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31662 PyObject *obj;
31663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31664 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31665 return SWIG_Py_Void();
31666 }
31667
31668 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31669 return SWIG_Python_InitShadowInstance(args);
31670 }
31671
31672 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31673 PyObject *resultobj = 0;
31674 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31675 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31676 wxBitmapDataObject *result = 0 ;
31677 void *argp1 = 0 ;
31678 int res1 = 0 ;
31679 PyObject * obj0 = 0 ;
31680 char * kwnames[] = {
31681 (char *) "bitmap", NULL
31682 };
31683
31684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31685 if (obj0) {
31686 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31689 }
31690 if (!argp1) {
31691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31692 }
31693 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31694 }
31695 {
31696 PyThreadState* __tstate = wxPyBeginAllowThreads();
31697 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31698 wxPyEndAllowThreads(__tstate);
31699 if (PyErr_Occurred()) SWIG_fail;
31700 }
31701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31709 PyObject *resultobj = 0;
31710 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31711 wxBitmap result;
31712 void *argp1 = 0 ;
31713 int res1 = 0 ;
31714 PyObject *swig_obj[1] ;
31715
31716 if (!args) SWIG_fail;
31717 swig_obj[0] = args;
31718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31721 }
31722 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31726 wxPyEndAllowThreads(__tstate);
31727 if (PyErr_Occurred()) SWIG_fail;
31728 }
31729 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31730 return resultobj;
31731 fail:
31732 return NULL;
31733 }
31734
31735
31736 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31737 PyObject *resultobj = 0;
31738 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31739 wxBitmap *arg2 = 0 ;
31740 void *argp1 = 0 ;
31741 int res1 = 0 ;
31742 void *argp2 = 0 ;
31743 int res2 = 0 ;
31744 PyObject * obj0 = 0 ;
31745 PyObject * obj1 = 0 ;
31746 char * kwnames[] = {
31747 (char *) "self",(char *) "bitmap", NULL
31748 };
31749
31750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31754 }
31755 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31757 if (!SWIG_IsOK(res2)) {
31758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31759 }
31760 if (!argp2) {
31761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31762 }
31763 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31764 {
31765 PyThreadState* __tstate = wxPyBeginAllowThreads();
31766 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_Py_Void();
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31778 PyObject *obj;
31779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31780 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31781 return SWIG_Py_Void();
31782 }
31783
31784 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31785 return SWIG_Python_InitShadowInstance(args);
31786 }
31787
31788 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj = 0;
31790 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31791 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31792 wxPyBitmapDataObject *result = 0 ;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 PyObject * obj0 = 0 ;
31796 char * kwnames[] = {
31797 (char *) "bitmap", NULL
31798 };
31799
31800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31801 if (obj0) {
31802 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31803 if (!SWIG_IsOK(res1)) {
31804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31805 }
31806 if (!argp1) {
31807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31808 }
31809 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31810 }
31811 {
31812 PyThreadState* __tstate = wxPyBeginAllowThreads();
31813 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31814 wxPyEndAllowThreads(__tstate);
31815 if (PyErr_Occurred()) SWIG_fail;
31816 }
31817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31818 return resultobj;
31819 fail:
31820 return NULL;
31821 }
31822
31823
31824 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31825 PyObject *resultobj = 0;
31826 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31827 PyObject *arg2 = (PyObject *) 0 ;
31828 PyObject *arg3 = (PyObject *) 0 ;
31829 void *argp1 = 0 ;
31830 int res1 = 0 ;
31831 PyObject * obj0 = 0 ;
31832 PyObject * obj1 = 0 ;
31833 PyObject * obj2 = 0 ;
31834 char * kwnames[] = {
31835 (char *) "self",(char *) "self",(char *) "_class", NULL
31836 };
31837
31838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31840 if (!SWIG_IsOK(res1)) {
31841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31842 }
31843 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31844 arg2 = obj1;
31845 arg3 = obj2;
31846 {
31847 PyThreadState* __tstate = wxPyBeginAllowThreads();
31848 (arg1)->_setCallbackInfo(arg2,arg3);
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 resultobj = SWIG_Py_Void();
31853 return resultobj;
31854 fail:
31855 return NULL;
31856 }
31857
31858
31859 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31860 PyObject *obj;
31861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31863 return SWIG_Py_Void();
31864 }
31865
31866 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31867 return SWIG_Python_InitShadowInstance(args);
31868 }
31869
31870 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31871 PyObject *resultobj = 0;
31872 wxFileDataObject *result = 0 ;
31873
31874 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 result = (wxFileDataObject *)new wxFileDataObject();
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31882 return resultobj;
31883 fail:
31884 return NULL;
31885 }
31886
31887
31888 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31889 PyObject *resultobj = 0;
31890 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31891 wxArrayString *result = 0 ;
31892 void *argp1 = 0 ;
31893 int res1 = 0 ;
31894 PyObject *swig_obj[1] ;
31895
31896 if (!args) SWIG_fail;
31897 swig_obj[0] = args;
31898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31899 if (!SWIG_IsOK(res1)) {
31900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31901 }
31902 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31903 {
31904 PyThreadState* __tstate = wxPyBeginAllowThreads();
31905 {
31906 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31907 result = (wxArrayString *) &_result_ref;
31908 }
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 {
31913 resultobj = wxArrayString2PyList_helper(*result);
31914 }
31915 return resultobj;
31916 fail:
31917 return NULL;
31918 }
31919
31920
31921 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31922 PyObject *resultobj = 0;
31923 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31924 wxString *arg2 = 0 ;
31925 void *argp1 = 0 ;
31926 int res1 = 0 ;
31927 bool temp2 = false ;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 char * kwnames[] = {
31931 (char *) "self",(char *) "filename", NULL
31932 };
31933
31934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31936 if (!SWIG_IsOK(res1)) {
31937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31938 }
31939 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31940 {
31941 arg2 = wxString_in_helper(obj1);
31942 if (arg2 == NULL) SWIG_fail;
31943 temp2 = true;
31944 }
31945 {
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 (arg1)->AddFile((wxString const &)*arg2);
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_Py_Void();
31952 {
31953 if (temp2)
31954 delete arg2;
31955 }
31956 return resultobj;
31957 fail:
31958 {
31959 if (temp2)
31960 delete arg2;
31961 }
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *obj;
31968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31969 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31970 return SWIG_Py_Void();
31971 }
31972
31973 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 return SWIG_Python_InitShadowInstance(args);
31975 }
31976
31977 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31978 PyObject *resultobj = 0;
31979 wxDataFormat *arg1 = 0 ;
31980 wxCustomDataObject *result = 0 ;
31981 void *argp1 = 0 ;
31982 int res1 = 0 ;
31983
31984 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31986 if (!SWIG_IsOK(res1)) {
31987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31988 }
31989 if (!argp1) {
31990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31991 }
31992 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32007 PyObject *resultobj = 0;
32008 wxString *arg1 = 0 ;
32009 wxCustomDataObject *result = 0 ;
32010 bool temp1 = false ;
32011
32012 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32013 {
32014 arg1 = wxString_in_helper(swig_obj[0]);
32015 if (arg1 == NULL) SWIG_fail;
32016 temp1 = true;
32017 }
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32025 {
32026 if (temp1)
32027 delete arg1;
32028 }
32029 return resultobj;
32030 fail:
32031 {
32032 if (temp1)
32033 delete arg1;
32034 }
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32040 PyObject *resultobj = 0;
32041 wxCustomDataObject *result = 0 ;
32042
32043 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = (wxCustomDataObject *)new wxCustomDataObject();
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32058 int argc;
32059 PyObject *argv[2];
32060
32061 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32062 --argc;
32063 if (argc == 0) {
32064 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32065 }
32066 if (argc == 1) {
32067 int _v = 0;
32068 {
32069 {
32070 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32071 }
32072 }
32073 if (!_v) goto check_2;
32074 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32075 }
32076 check_2:
32077
32078 if (argc == 1) {
32079 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32080 }
32081
32082 fail:
32083 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj = 0;
32090 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32091 PyObject *arg2 = (PyObject *) 0 ;
32092 bool result;
32093 void *argp1 = 0 ;
32094 int res1 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "data", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32105 }
32106 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32107 arg2 = obj1;
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 {
32115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32116 }
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32124 PyObject *resultobj = 0;
32125 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32126 size_t result;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 PyObject *swig_obj[1] ;
32130
32131 if (!args) SWIG_fail;
32132 swig_obj[0] = args;
32133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32134 if (!SWIG_IsOK(res1)) {
32135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32136 }
32137 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 result = (size_t)(arg1)->GetSize();
32141 wxPyEndAllowThreads(__tstate);
32142 if (PyErr_Occurred()) SWIG_fail;
32143 }
32144 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32145 return resultobj;
32146 fail:
32147 return NULL;
32148 }
32149
32150
32151 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32152 PyObject *resultobj = 0;
32153 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32154 PyObject *result = 0 ;
32155 void *argp1 = 0 ;
32156 int res1 = 0 ;
32157 PyObject *swig_obj[1] ;
32158
32159 if (!args) SWIG_fail;
32160 swig_obj[0] = args;
32161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32162 if (!SWIG_IsOK(res1)) {
32163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32164 }
32165 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 resultobj = result;
32173 return resultobj;
32174 fail:
32175 return NULL;
32176 }
32177
32178
32179 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32180 PyObject *obj;
32181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32182 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32183 return SWIG_Py_Void();
32184 }
32185
32186 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 return SWIG_Python_InitShadowInstance(args);
32188 }
32189
32190 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32191 PyObject *resultobj = 0;
32192 wxURLDataObject *result = 0 ;
32193
32194 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = (wxURLDataObject *)new wxURLDataObject();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32211 wxString result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32221 }
32222 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = (arg1)->GetURL();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 #if wxUSE_UNICODE
32231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32232 #else
32233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32234 #endif
32235 }
32236 return resultobj;
32237 fail:
32238 return NULL;
32239 }
32240
32241
32242 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32243 PyObject *resultobj = 0;
32244 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32245 wxString *arg2 = 0 ;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 bool temp2 = false ;
32249 PyObject * obj0 = 0 ;
32250 PyObject * obj1 = 0 ;
32251 char * kwnames[] = {
32252 (char *) "self",(char *) "url", NULL
32253 };
32254
32255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32257 if (!SWIG_IsOK(res1)) {
32258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32259 }
32260 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32261 {
32262 arg2 = wxString_in_helper(obj1);
32263 if (arg2 == NULL) SWIG_fail;
32264 temp2 = true;
32265 }
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 (arg1)->SetURL((wxString const &)*arg2);
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 resultobj = SWIG_Py_Void();
32273 {
32274 if (temp2)
32275 delete arg2;
32276 }
32277 return resultobj;
32278 fail:
32279 {
32280 if (temp2)
32281 delete arg2;
32282 }
32283 return NULL;
32284 }
32285
32286
32287 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32288 PyObject *obj;
32289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32290 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32291 return SWIG_Py_Void();
32292 }
32293
32294 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 return SWIG_Python_InitShadowInstance(args);
32296 }
32297
32298 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32299 PyObject *resultobj = 0;
32300 wxMetafileDataObject *result = 0 ;
32301
32302 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32317 PyObject *obj;
32318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32319 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32320 return SWIG_Py_Void();
32321 }
32322
32323 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32324 return SWIG_Python_InitShadowInstance(args);
32325 }
32326
32327 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj = 0;
32329 wxDragResult arg1 ;
32330 bool result;
32331 int val1 ;
32332 int ecode1 = 0 ;
32333 PyObject * obj0 = 0 ;
32334 char * kwnames[] = {
32335 (char *) "res", NULL
32336 };
32337
32338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32339 ecode1 = SWIG_AsVal_int(obj0, &val1);
32340 if (!SWIG_IsOK(ecode1)) {
32341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32342 }
32343 arg1 = static_cast< wxDragResult >(val1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (bool)wxIsDragResultOk(arg1);
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32352 }
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32360 PyObject *resultobj = 0;
32361 wxWindow *arg1 = (wxWindow *) 0 ;
32362 wxIcon const &arg2_defvalue = wxNullIcon ;
32363 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32364 wxIcon const &arg3_defvalue = wxNullIcon ;
32365 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32366 wxIcon const &arg4_defvalue = wxNullIcon ;
32367 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32368 wxPyDropSource *result = 0 ;
32369 void *argp1 = 0 ;
32370 int res1 = 0 ;
32371 void *argp2 = 0 ;
32372 int res2 = 0 ;
32373 void *argp3 = 0 ;
32374 int res3 = 0 ;
32375 void *argp4 = 0 ;
32376 int res4 = 0 ;
32377 PyObject * obj0 = 0 ;
32378 PyObject * obj1 = 0 ;
32379 PyObject * obj2 = 0 ;
32380 PyObject * obj3 = 0 ;
32381 char * kwnames[] = {
32382 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32383 };
32384
32385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 if (obj1) {
32392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32393 if (!SWIG_IsOK(res2)) {
32394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32395 }
32396 if (!argp2) {
32397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32398 }
32399 arg2 = reinterpret_cast< wxIcon * >(argp2);
32400 }
32401 if (obj2) {
32402 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32403 if (!SWIG_IsOK(res3)) {
32404 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32405 }
32406 if (!argp3) {
32407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32408 }
32409 arg3 = reinterpret_cast< wxIcon * >(argp3);
32410 }
32411 if (obj3) {
32412 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32413 if (!SWIG_IsOK(res4)) {
32414 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32415 }
32416 if (!argp4) {
32417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32418 }
32419 arg4 = reinterpret_cast< wxIcon * >(argp4);
32420 }
32421 {
32422 PyThreadState* __tstate = wxPyBeginAllowThreads();
32423 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32424 wxPyEndAllowThreads(__tstate);
32425 if (PyErr_Occurred()) SWIG_fail;
32426 }
32427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32435 PyObject *resultobj = 0;
32436 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32437 PyObject *arg2 = (PyObject *) 0 ;
32438 PyObject *arg3 = (PyObject *) 0 ;
32439 int arg4 ;
32440 void *argp1 = 0 ;
32441 int res1 = 0 ;
32442 int val4 ;
32443 int ecode4 = 0 ;
32444 PyObject * obj0 = 0 ;
32445 PyObject * obj1 = 0 ;
32446 PyObject * obj2 = 0 ;
32447 PyObject * obj3 = 0 ;
32448 char * kwnames[] = {
32449 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32450 };
32451
32452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32454 if (!SWIG_IsOK(res1)) {
32455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32456 }
32457 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32458 arg2 = obj1;
32459 arg3 = obj2;
32460 ecode4 = SWIG_AsVal_int(obj3, &val4);
32461 if (!SWIG_IsOK(ecode4)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32463 }
32464 arg4 = static_cast< int >(val4);
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 resultobj = SWIG_Py_Void();
32472 return resultobj;
32473 fail:
32474 return NULL;
32475 }
32476
32477
32478 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32479 PyObject *resultobj = 0;
32480 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32481 void *argp1 = 0 ;
32482 int res1 = 0 ;
32483 PyObject *swig_obj[1] ;
32484
32485 if (!args) SWIG_fail;
32486 swig_obj[0] = args;
32487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32488 if (!SWIG_IsOK(res1)) {
32489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32490 }
32491 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 delete arg1;
32495
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 resultobj = SWIG_Py_Void();
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32507 PyObject *resultobj = 0;
32508 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32509 wxDataObject *arg2 = 0 ;
32510 void *argp1 = 0 ;
32511 int res1 = 0 ;
32512 void *argp2 = 0 ;
32513 int res2 = 0 ;
32514 PyObject * obj0 = 0 ;
32515 PyObject * obj1 = 0 ;
32516 char * kwnames[] = {
32517 (char *) "self",(char *) "data", NULL
32518 };
32519
32520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32522 if (!SWIG_IsOK(res1)) {
32523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32524 }
32525 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32526 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32527 if (!SWIG_IsOK(res2)) {
32528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32529 }
32530 if (!argp2) {
32531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32532 }
32533 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32534 {
32535 PyThreadState* __tstate = wxPyBeginAllowThreads();
32536 (arg1)->SetData(*arg2);
32537 wxPyEndAllowThreads(__tstate);
32538 if (PyErr_Occurred()) SWIG_fail;
32539 }
32540 resultobj = SWIG_Py_Void();
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32550 wxDataObject *result = 0 ;
32551 void *argp1 = 0 ;
32552 int res1 = 0 ;
32553 PyObject *swig_obj[1] ;
32554
32555 if (!args) SWIG_fail;
32556 swig_obj[0] = args;
32557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32558 if (!SWIG_IsOK(res1)) {
32559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32560 }
32561 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 result = (wxDataObject *)(arg1)->GetDataObject();
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32576 PyObject *resultobj = 0;
32577 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32578 wxDragResult arg2 ;
32579 wxCursor *arg3 = 0 ;
32580 void *argp1 = 0 ;
32581 int res1 = 0 ;
32582 int val2 ;
32583 int ecode2 = 0 ;
32584 void *argp3 = 0 ;
32585 int res3 = 0 ;
32586 PyObject * obj0 = 0 ;
32587 PyObject * obj1 = 0 ;
32588 PyObject * obj2 = 0 ;
32589 char * kwnames[] = {
32590 (char *) "self",(char *) "res",(char *) "cursor", NULL
32591 };
32592
32593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32595 if (!SWIG_IsOK(res1)) {
32596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32597 }
32598 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32599 ecode2 = SWIG_AsVal_int(obj1, &val2);
32600 if (!SWIG_IsOK(ecode2)) {
32601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32602 }
32603 arg2 = static_cast< wxDragResult >(val2);
32604 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32605 if (!SWIG_IsOK(res3)) {
32606 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32607 }
32608 if (!argp3) {
32609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32610 }
32611 arg3 = reinterpret_cast< wxCursor * >(argp3);
32612 {
32613 PyThreadState* __tstate = wxPyBeginAllowThreads();
32614 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32615 wxPyEndAllowThreads(__tstate);
32616 if (PyErr_Occurred()) SWIG_fail;
32617 }
32618 resultobj = SWIG_Py_Void();
32619 return resultobj;
32620 fail:
32621 return NULL;
32622 }
32623
32624
32625 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32626 PyObject *resultobj = 0;
32627 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32628 int arg2 = (int) wxDrag_CopyOnly ;
32629 wxDragResult result;
32630 void *argp1 = 0 ;
32631 int res1 = 0 ;
32632 int val2 ;
32633 int ecode2 = 0 ;
32634 PyObject * obj0 = 0 ;
32635 PyObject * obj1 = 0 ;
32636 char * kwnames[] = {
32637 (char *) "self",(char *) "flags", NULL
32638 };
32639
32640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32644 }
32645 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32646 if (obj1) {
32647 ecode2 = SWIG_AsVal_int(obj1, &val2);
32648 if (!SWIG_IsOK(ecode2)) {
32649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32650 }
32651 arg2 = static_cast< int >(val2);
32652 }
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 resultobj = SWIG_From_int(static_cast< int >(result));
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32667 PyObject *resultobj = 0;
32668 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32669 wxDragResult arg2 ;
32670 bool result;
32671 void *argp1 = 0 ;
32672 int res1 = 0 ;
32673 int val2 ;
32674 int ecode2 = 0 ;
32675 PyObject * obj0 = 0 ;
32676 PyObject * obj1 = 0 ;
32677 char * kwnames[] = {
32678 (char *) "self",(char *) "effect", NULL
32679 };
32680
32681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32683 if (!SWIG_IsOK(res1)) {
32684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32685 }
32686 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32687 ecode2 = SWIG_AsVal_int(obj1, &val2);
32688 if (!SWIG_IsOK(ecode2)) {
32689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32690 }
32691 arg2 = static_cast< wxDragResult >(val2);
32692 {
32693 PyThreadState* __tstate = wxPyBeginAllowThreads();
32694 result = (bool)(arg1)->GiveFeedback(arg2);
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 {
32699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32700 }
32701 return resultobj;
32702 fail:
32703 return NULL;
32704 }
32705
32706
32707 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32708 PyObject *obj;
32709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32710 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32711 return SWIG_Py_Void();
32712 }
32713
32714 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32715 return SWIG_Python_InitShadowInstance(args);
32716 }
32717
32718 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32719 PyObject *resultobj = 0;
32720 wxDataObject *arg1 = (wxDataObject *) NULL ;
32721 wxPyDropTarget *result = 0 ;
32722 int res1 = 0 ;
32723 PyObject * obj0 = 0 ;
32724 char * kwnames[] = {
32725 (char *) "dataObject", NULL
32726 };
32727
32728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32729 if (obj0) {
32730 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32731 if (!SWIG_IsOK(res1)) {
32732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32733 }
32734 }
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32742 return resultobj;
32743 fail:
32744 return NULL;
32745 }
32746
32747
32748 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32749 PyObject *resultobj = 0;
32750 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32751 PyObject *arg2 = (PyObject *) 0 ;
32752 PyObject *arg3 = (PyObject *) 0 ;
32753 void *argp1 = 0 ;
32754 int res1 = 0 ;
32755 PyObject * obj0 = 0 ;
32756 PyObject * obj1 = 0 ;
32757 PyObject * obj2 = 0 ;
32758 char * kwnames[] = {
32759 (char *) "self",(char *) "self",(char *) "_class", NULL
32760 };
32761
32762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32764 if (!SWIG_IsOK(res1)) {
32765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32766 }
32767 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32768 arg2 = obj1;
32769 arg3 = obj2;
32770 {
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 (arg1)->_setCallbackInfo(arg2,arg3);
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 resultobj = SWIG_Py_Void();
32777 return resultobj;
32778 fail:
32779 return NULL;
32780 }
32781
32782
32783 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32784 PyObject *resultobj = 0;
32785 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32786 void *argp1 = 0 ;
32787 int res1 = 0 ;
32788 PyObject *swig_obj[1] ;
32789
32790 if (!args) SWIG_fail;
32791 swig_obj[0] = args;
32792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32793 if (!SWIG_IsOK(res1)) {
32794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32795 }
32796 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32797 {
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 delete arg1;
32800
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 resultobj = SWIG_Py_Void();
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32812 PyObject *resultobj = 0;
32813 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32814 wxDataObject *result = 0 ;
32815 void *argp1 = 0 ;
32816 int res1 = 0 ;
32817 PyObject *swig_obj[1] ;
32818
32819 if (!args) SWIG_fail;
32820 swig_obj[0] = args;
32821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32824 }
32825 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (wxDataObject *)(arg1)->GetDataObject();
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj = 0;
32841 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32842 wxDataObject *arg2 = (wxDataObject *) 0 ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 int res2 = 0 ;
32846 PyObject * obj0 = 0 ;
32847 PyObject * obj1 = 0 ;
32848 char * kwnames[] = {
32849 (char *) "self",(char *) "dataObject", NULL
32850 };
32851
32852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32854 if (!SWIG_IsOK(res1)) {
32855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32856 }
32857 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32858 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32859 if (!SWIG_IsOK(res2)) {
32860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32861 }
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 (arg1)->SetDataObject(arg2);
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 resultobj = SWIG_Py_Void();
32869 return resultobj;
32870 fail:
32871 return NULL;
32872 }
32873
32874
32875 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32876 PyObject *resultobj = 0;
32877 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32878 int arg2 ;
32879 int arg3 ;
32880 wxDragResult arg4 ;
32881 wxDragResult result;
32882 void *argp1 = 0 ;
32883 int res1 = 0 ;
32884 int val2 ;
32885 int ecode2 = 0 ;
32886 int val3 ;
32887 int ecode3 = 0 ;
32888 int val4 ;
32889 int ecode4 = 0 ;
32890 PyObject * obj0 = 0 ;
32891 PyObject * obj1 = 0 ;
32892 PyObject * obj2 = 0 ;
32893 PyObject * obj3 = 0 ;
32894 char * kwnames[] = {
32895 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32896 };
32897
32898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32900 if (!SWIG_IsOK(res1)) {
32901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32902 }
32903 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32904 ecode2 = SWIG_AsVal_int(obj1, &val2);
32905 if (!SWIG_IsOK(ecode2)) {
32906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32907 }
32908 arg2 = static_cast< int >(val2);
32909 ecode3 = SWIG_AsVal_int(obj2, &val3);
32910 if (!SWIG_IsOK(ecode3)) {
32911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32912 }
32913 arg3 = static_cast< int >(val3);
32914 ecode4 = SWIG_AsVal_int(obj3, &val4);
32915 if (!SWIG_IsOK(ecode4)) {
32916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32917 }
32918 arg4 = static_cast< wxDragResult >(val4);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 resultobj = SWIG_From_int(static_cast< int >(result));
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32933 PyObject *resultobj = 0;
32934 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32935 int arg2 ;
32936 int arg3 ;
32937 wxDragResult arg4 ;
32938 wxDragResult result;
32939 void *argp1 = 0 ;
32940 int res1 = 0 ;
32941 int val2 ;
32942 int ecode2 = 0 ;
32943 int val3 ;
32944 int ecode3 = 0 ;
32945 int val4 ;
32946 int ecode4 = 0 ;
32947 PyObject * obj0 = 0 ;
32948 PyObject * obj1 = 0 ;
32949 PyObject * obj2 = 0 ;
32950 PyObject * obj3 = 0 ;
32951 char * kwnames[] = {
32952 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32953 };
32954
32955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32959 }
32960 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32961 ecode2 = SWIG_AsVal_int(obj1, &val2);
32962 if (!SWIG_IsOK(ecode2)) {
32963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32964 }
32965 arg2 = static_cast< int >(val2);
32966 ecode3 = SWIG_AsVal_int(obj2, &val3);
32967 if (!SWIG_IsOK(ecode3)) {
32968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32969 }
32970 arg3 = static_cast< int >(val3);
32971 ecode4 = SWIG_AsVal_int(obj3, &val4);
32972 if (!SWIG_IsOK(ecode4)) {
32973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32974 }
32975 arg4 = static_cast< wxDragResult >(val4);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 resultobj = SWIG_From_int(static_cast< int >(result));
32983 return resultobj;
32984 fail:
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32990 PyObject *resultobj = 0;
32991 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32992 void *argp1 = 0 ;
32993 int res1 = 0 ;
32994 PyObject *swig_obj[1] ;
32995
32996 if (!args) SWIG_fail;
32997 swig_obj[0] = args;
32998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32999 if (!SWIG_IsOK(res1)) {
33000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33001 }
33002 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33003 {
33004 PyThreadState* __tstate = wxPyBeginAllowThreads();
33005 (arg1)->OnLeave();
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 resultobj = SWIG_Py_Void();
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj = 0;
33018 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33019 int arg2 ;
33020 int arg3 ;
33021 bool result;
33022 void *argp1 = 0 ;
33023 int res1 = 0 ;
33024 int val2 ;
33025 int ecode2 = 0 ;
33026 int val3 ;
33027 int ecode3 = 0 ;
33028 PyObject * obj0 = 0 ;
33029 PyObject * obj1 = 0 ;
33030 PyObject * obj2 = 0 ;
33031 char * kwnames[] = {
33032 (char *) "self",(char *) "x",(char *) "y", NULL
33033 };
33034
33035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33039 }
33040 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33041 ecode2 = SWIG_AsVal_int(obj1, &val2);
33042 if (!SWIG_IsOK(ecode2)) {
33043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33044 }
33045 arg2 = static_cast< int >(val2);
33046 ecode3 = SWIG_AsVal_int(obj2, &val3);
33047 if (!SWIG_IsOK(ecode3)) {
33048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33049 }
33050 arg3 = static_cast< int >(val3);
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 result = (bool)(arg1)->OnDrop(arg2,arg3);
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 {
33058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33059 }
33060 return resultobj;
33061 fail:
33062 return NULL;
33063 }
33064
33065
33066 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33067 PyObject *resultobj = 0;
33068 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33069 bool result;
33070 void *argp1 = 0 ;
33071 int res1 = 0 ;
33072 PyObject *swig_obj[1] ;
33073
33074 if (!args) SWIG_fail;
33075 swig_obj[0] = args;
33076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33077 if (!SWIG_IsOK(res1)) {
33078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33079 }
33080 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 result = (bool)(arg1)->GetData();
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33089 }
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33097 PyObject *resultobj = 0;
33098 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33099 wxDragResult arg2 ;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 int val2 ;
33103 int ecode2 = 0 ;
33104 PyObject * obj0 = 0 ;
33105 PyObject * obj1 = 0 ;
33106 char * kwnames[] = {
33107 (char *) "self",(char *) "action", NULL
33108 };
33109
33110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33112 if (!SWIG_IsOK(res1)) {
33113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33114 }
33115 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33116 ecode2 = SWIG_AsVal_int(obj1, &val2);
33117 if (!SWIG_IsOK(ecode2)) {
33118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33119 }
33120 arg2 = static_cast< wxDragResult >(val2);
33121 {
33122 PyThreadState* __tstate = wxPyBeginAllowThreads();
33123 (arg1)->SetDefaultAction(arg2);
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 resultobj = SWIG_Py_Void();
33128 return resultobj;
33129 fail:
33130 return NULL;
33131 }
33132
33133
33134 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33135 PyObject *resultobj = 0;
33136 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33137 wxDragResult result;
33138 void *argp1 = 0 ;
33139 int res1 = 0 ;
33140 PyObject *swig_obj[1] ;
33141
33142 if (!args) SWIG_fail;
33143 swig_obj[0] = args;
33144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33147 }
33148 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 result = (wxDragResult)(arg1)->GetDefaultAction();
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 resultobj = SWIG_From_int(static_cast< int >(result));
33156 return resultobj;
33157 fail:
33158 return NULL;
33159 }
33160
33161
33162 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33163 PyObject *obj;
33164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33165 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33166 return SWIG_Py_Void();
33167 }
33168
33169 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33170 return SWIG_Python_InitShadowInstance(args);
33171 }
33172
33173 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33174 PyObject *resultobj = 0;
33175 wxPyTextDropTarget *result = 0 ;
33176
33177 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33192 PyObject *resultobj = 0;
33193 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33194 PyObject *arg2 = (PyObject *) 0 ;
33195 PyObject *arg3 = (PyObject *) 0 ;
33196 void *argp1 = 0 ;
33197 int res1 = 0 ;
33198 PyObject * obj0 = 0 ;
33199 PyObject * obj1 = 0 ;
33200 PyObject * obj2 = 0 ;
33201 char * kwnames[] = {
33202 (char *) "self",(char *) "self",(char *) "_class", NULL
33203 };
33204
33205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33207 if (!SWIG_IsOK(res1)) {
33208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33209 }
33210 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33211 arg2 = obj1;
33212 arg3 = obj2;
33213 {
33214 PyThreadState* __tstate = wxPyBeginAllowThreads();
33215 (arg1)->_setCallbackInfo(arg2,arg3);
33216 wxPyEndAllowThreads(__tstate);
33217 if (PyErr_Occurred()) SWIG_fail;
33218 }
33219 resultobj = SWIG_Py_Void();
33220 return resultobj;
33221 fail:
33222 return NULL;
33223 }
33224
33225
33226 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33227 PyObject *resultobj = 0;
33228 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33229 int arg2 ;
33230 int arg3 ;
33231 wxString *arg4 = 0 ;
33232 bool result;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 int val2 ;
33236 int ecode2 = 0 ;
33237 int val3 ;
33238 int ecode3 = 0 ;
33239 bool temp4 = false ;
33240 PyObject * obj0 = 0 ;
33241 PyObject * obj1 = 0 ;
33242 PyObject * obj2 = 0 ;
33243 PyObject * obj3 = 0 ;
33244 char * kwnames[] = {
33245 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33246 };
33247
33248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33250 if (!SWIG_IsOK(res1)) {
33251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33252 }
33253 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33254 ecode2 = SWIG_AsVal_int(obj1, &val2);
33255 if (!SWIG_IsOK(ecode2)) {
33256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33257 }
33258 arg2 = static_cast< int >(val2);
33259 ecode3 = SWIG_AsVal_int(obj2, &val3);
33260 if (!SWIG_IsOK(ecode3)) {
33261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33262 }
33263 arg3 = static_cast< int >(val3);
33264 {
33265 arg4 = wxString_in_helper(obj3);
33266 if (arg4 == NULL) SWIG_fail;
33267 temp4 = true;
33268 }
33269 {
33270 PyThreadState* __tstate = wxPyBeginAllowThreads();
33271 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33277 }
33278 {
33279 if (temp4)
33280 delete arg4;
33281 }
33282 return resultobj;
33283 fail:
33284 {
33285 if (temp4)
33286 delete arg4;
33287 }
33288 return NULL;
33289 }
33290
33291
33292 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33293 PyObject *resultobj = 0;
33294 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33295 int arg2 ;
33296 int arg3 ;
33297 wxDragResult arg4 ;
33298 wxDragResult result;
33299 void *argp1 = 0 ;
33300 int res1 = 0 ;
33301 int val2 ;
33302 int ecode2 = 0 ;
33303 int val3 ;
33304 int ecode3 = 0 ;
33305 int val4 ;
33306 int ecode4 = 0 ;
33307 PyObject * obj0 = 0 ;
33308 PyObject * obj1 = 0 ;
33309 PyObject * obj2 = 0 ;
33310 PyObject * obj3 = 0 ;
33311 char * kwnames[] = {
33312 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33313 };
33314
33315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33317 if (!SWIG_IsOK(res1)) {
33318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33319 }
33320 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33321 ecode2 = SWIG_AsVal_int(obj1, &val2);
33322 if (!SWIG_IsOK(ecode2)) {
33323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33324 }
33325 arg2 = static_cast< int >(val2);
33326 ecode3 = SWIG_AsVal_int(obj2, &val3);
33327 if (!SWIG_IsOK(ecode3)) {
33328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33329 }
33330 arg3 = static_cast< int >(val3);
33331 ecode4 = SWIG_AsVal_int(obj3, &val4);
33332 if (!SWIG_IsOK(ecode4)) {
33333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33334 }
33335 arg4 = static_cast< wxDragResult >(val4);
33336 {
33337 PyThreadState* __tstate = wxPyBeginAllowThreads();
33338 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33339 wxPyEndAllowThreads(__tstate);
33340 if (PyErr_Occurred()) SWIG_fail;
33341 }
33342 resultobj = SWIG_From_int(static_cast< int >(result));
33343 return resultobj;
33344 fail:
33345 return NULL;
33346 }
33347
33348
33349 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33350 PyObject *resultobj = 0;
33351 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33352 int arg2 ;
33353 int arg3 ;
33354 wxDragResult arg4 ;
33355 wxDragResult result;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 int val2 ;
33359 int ecode2 = 0 ;
33360 int val3 ;
33361 int ecode3 = 0 ;
33362 int val4 ;
33363 int ecode4 = 0 ;
33364 PyObject * obj0 = 0 ;
33365 PyObject * obj1 = 0 ;
33366 PyObject * obj2 = 0 ;
33367 PyObject * obj3 = 0 ;
33368 char * kwnames[] = {
33369 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33370 };
33371
33372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33374 if (!SWIG_IsOK(res1)) {
33375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33376 }
33377 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33378 ecode2 = SWIG_AsVal_int(obj1, &val2);
33379 if (!SWIG_IsOK(ecode2)) {
33380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33381 }
33382 arg2 = static_cast< int >(val2);
33383 ecode3 = SWIG_AsVal_int(obj2, &val3);
33384 if (!SWIG_IsOK(ecode3)) {
33385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33386 }
33387 arg3 = static_cast< int >(val3);
33388 ecode4 = SWIG_AsVal_int(obj3, &val4);
33389 if (!SWIG_IsOK(ecode4)) {
33390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33391 }
33392 arg4 = static_cast< wxDragResult >(val4);
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 resultobj = SWIG_From_int(static_cast< int >(result));
33400 return resultobj;
33401 fail:
33402 return NULL;
33403 }
33404
33405
33406 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33407 PyObject *resultobj = 0;
33408 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33409 void *argp1 = 0 ;
33410 int res1 = 0 ;
33411 PyObject *swig_obj[1] ;
33412
33413 if (!args) SWIG_fail;
33414 swig_obj[0] = args;
33415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33416 if (!SWIG_IsOK(res1)) {
33417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33418 }
33419 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33420 {
33421 PyThreadState* __tstate = wxPyBeginAllowThreads();
33422 (arg1)->OnLeave();
33423 wxPyEndAllowThreads(__tstate);
33424 if (PyErr_Occurred()) SWIG_fail;
33425 }
33426 resultobj = SWIG_Py_Void();
33427 return resultobj;
33428 fail:
33429 return NULL;
33430 }
33431
33432
33433 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33434 PyObject *resultobj = 0;
33435 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33436 int arg2 ;
33437 int arg3 ;
33438 bool result;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 int val2 ;
33442 int ecode2 = 0 ;
33443 int val3 ;
33444 int ecode3 = 0 ;
33445 PyObject * obj0 = 0 ;
33446 PyObject * obj1 = 0 ;
33447 PyObject * obj2 = 0 ;
33448 char * kwnames[] = {
33449 (char *) "self",(char *) "x",(char *) "y", NULL
33450 };
33451
33452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33454 if (!SWIG_IsOK(res1)) {
33455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33456 }
33457 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33458 ecode2 = SWIG_AsVal_int(obj1, &val2);
33459 if (!SWIG_IsOK(ecode2)) {
33460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33461 }
33462 arg2 = static_cast< int >(val2);
33463 ecode3 = SWIG_AsVal_int(obj2, &val3);
33464 if (!SWIG_IsOK(ecode3)) {
33465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33466 }
33467 arg3 = static_cast< int >(val3);
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (bool)(arg1)->OnDrop(arg2,arg3);
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 {
33475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33476 }
33477 return resultobj;
33478 fail:
33479 return NULL;
33480 }
33481
33482
33483 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33484 PyObject *resultobj = 0;
33485 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33486 int arg2 ;
33487 int arg3 ;
33488 wxDragResult arg4 ;
33489 wxDragResult result;
33490 void *argp1 = 0 ;
33491 int res1 = 0 ;
33492 int val2 ;
33493 int ecode2 = 0 ;
33494 int val3 ;
33495 int ecode3 = 0 ;
33496 int val4 ;
33497 int ecode4 = 0 ;
33498 PyObject * obj0 = 0 ;
33499 PyObject * obj1 = 0 ;
33500 PyObject * obj2 = 0 ;
33501 PyObject * obj3 = 0 ;
33502 char * kwnames[] = {
33503 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33504 };
33505
33506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33508 if (!SWIG_IsOK(res1)) {
33509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33510 }
33511 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33512 ecode2 = SWIG_AsVal_int(obj1, &val2);
33513 if (!SWIG_IsOK(ecode2)) {
33514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33515 }
33516 arg2 = static_cast< int >(val2);
33517 ecode3 = SWIG_AsVal_int(obj2, &val3);
33518 if (!SWIG_IsOK(ecode3)) {
33519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33520 }
33521 arg3 = static_cast< int >(val3);
33522 ecode4 = SWIG_AsVal_int(obj3, &val4);
33523 if (!SWIG_IsOK(ecode4)) {
33524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33525 }
33526 arg4 = static_cast< wxDragResult >(val4);
33527 {
33528 PyThreadState* __tstate = wxPyBeginAllowThreads();
33529 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 resultobj = SWIG_From_int(static_cast< int >(result));
33534 return resultobj;
33535 fail:
33536 return NULL;
33537 }
33538
33539
33540 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33541 PyObject *obj;
33542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33543 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33544 return SWIG_Py_Void();
33545 }
33546
33547 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 return SWIG_Python_InitShadowInstance(args);
33549 }
33550
33551 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33552 PyObject *resultobj = 0;
33553 wxPyFileDropTarget *result = 0 ;
33554
33555 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33556 {
33557 PyThreadState* __tstate = wxPyBeginAllowThreads();
33558 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33559 wxPyEndAllowThreads(__tstate);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 }
33562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33563 return resultobj;
33564 fail:
33565 return NULL;
33566 }
33567
33568
33569 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33570 PyObject *resultobj = 0;
33571 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33572 PyObject *arg2 = (PyObject *) 0 ;
33573 PyObject *arg3 = (PyObject *) 0 ;
33574 void *argp1 = 0 ;
33575 int res1 = 0 ;
33576 PyObject * obj0 = 0 ;
33577 PyObject * obj1 = 0 ;
33578 PyObject * obj2 = 0 ;
33579 char * kwnames[] = {
33580 (char *) "self",(char *) "self",(char *) "_class", NULL
33581 };
33582
33583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33587 }
33588 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33589 arg2 = obj1;
33590 arg3 = obj2;
33591 {
33592 PyThreadState* __tstate = wxPyBeginAllowThreads();
33593 (arg1)->_setCallbackInfo(arg2,arg3);
33594 wxPyEndAllowThreads(__tstate);
33595 if (PyErr_Occurred()) SWIG_fail;
33596 }
33597 resultobj = SWIG_Py_Void();
33598 return resultobj;
33599 fail:
33600 return NULL;
33601 }
33602
33603
33604 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33605 PyObject *resultobj = 0;
33606 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33607 int arg2 ;
33608 int arg3 ;
33609 wxArrayString *arg4 = 0 ;
33610 bool result;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 int val2 ;
33614 int ecode2 = 0 ;
33615 int val3 ;
33616 int ecode3 = 0 ;
33617 bool temp4 = false ;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 PyObject * obj2 = 0 ;
33621 PyObject * obj3 = 0 ;
33622 char * kwnames[] = {
33623 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33624 };
33625
33626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33630 }
33631 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33632 ecode2 = SWIG_AsVal_int(obj1, &val2);
33633 if (!SWIG_IsOK(ecode2)) {
33634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33635 }
33636 arg2 = static_cast< int >(val2);
33637 ecode3 = SWIG_AsVal_int(obj2, &val3);
33638 if (!SWIG_IsOK(ecode3)) {
33639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33640 }
33641 arg3 = static_cast< int >(val3);
33642 {
33643 if (! PySequence_Check(obj3)) {
33644 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33645 SWIG_fail;
33646 }
33647 arg4 = new wxArrayString;
33648 temp4 = true;
33649 int i, len=PySequence_Length(obj3);
33650 for (i=0; i<len; i++) {
33651 PyObject* item = PySequence_GetItem(obj3, i);
33652 wxString* s = wxString_in_helper(item);
33653 if (PyErr_Occurred()) SWIG_fail;
33654 arg4->Add(*s);
33655 delete s;
33656 Py_DECREF(item);
33657 }
33658 }
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33667 }
33668 {
33669 if (temp4) delete arg4;
33670 }
33671 return resultobj;
33672 fail:
33673 {
33674 if (temp4) delete arg4;
33675 }
33676 return NULL;
33677 }
33678
33679
33680 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj = 0;
33682 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33683 int arg2 ;
33684 int arg3 ;
33685 wxDragResult arg4 ;
33686 wxDragResult result;
33687 void *argp1 = 0 ;
33688 int res1 = 0 ;
33689 int val2 ;
33690 int ecode2 = 0 ;
33691 int val3 ;
33692 int ecode3 = 0 ;
33693 int val4 ;
33694 int ecode4 = 0 ;
33695 PyObject * obj0 = 0 ;
33696 PyObject * obj1 = 0 ;
33697 PyObject * obj2 = 0 ;
33698 PyObject * obj3 = 0 ;
33699 char * kwnames[] = {
33700 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33701 };
33702
33703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33705 if (!SWIG_IsOK(res1)) {
33706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33707 }
33708 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33709 ecode2 = SWIG_AsVal_int(obj1, &val2);
33710 if (!SWIG_IsOK(ecode2)) {
33711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33712 }
33713 arg2 = static_cast< int >(val2);
33714 ecode3 = SWIG_AsVal_int(obj2, &val3);
33715 if (!SWIG_IsOK(ecode3)) {
33716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33717 }
33718 arg3 = static_cast< int >(val3);
33719 ecode4 = SWIG_AsVal_int(obj3, &val4);
33720 if (!SWIG_IsOK(ecode4)) {
33721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33722 }
33723 arg4 = static_cast< wxDragResult >(val4);
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 resultobj = SWIG_From_int(static_cast< int >(result));
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33740 int arg2 ;
33741 int arg3 ;
33742 wxDragResult arg4 ;
33743 wxDragResult result;
33744 void *argp1 = 0 ;
33745 int res1 = 0 ;
33746 int val2 ;
33747 int ecode2 = 0 ;
33748 int val3 ;
33749 int ecode3 = 0 ;
33750 int val4 ;
33751 int ecode4 = 0 ;
33752 PyObject * obj0 = 0 ;
33753 PyObject * obj1 = 0 ;
33754 PyObject * obj2 = 0 ;
33755 PyObject * obj3 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33764 }
33765 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33766 ecode2 = SWIG_AsVal_int(obj1, &val2);
33767 if (!SWIG_IsOK(ecode2)) {
33768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33769 }
33770 arg2 = static_cast< int >(val2);
33771 ecode3 = SWIG_AsVal_int(obj2, &val3);
33772 if (!SWIG_IsOK(ecode3)) {
33773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33774 }
33775 arg3 = static_cast< int >(val3);
33776 ecode4 = SWIG_AsVal_int(obj3, &val4);
33777 if (!SWIG_IsOK(ecode4)) {
33778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33779 }
33780 arg4 = static_cast< wxDragResult >(val4);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 resultobj = SWIG_From_int(static_cast< int >(result));
33788 return resultobj;
33789 fail:
33790 return NULL;
33791 }
33792
33793
33794 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33795 PyObject *resultobj = 0;
33796 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33797 void *argp1 = 0 ;
33798 int res1 = 0 ;
33799 PyObject *swig_obj[1] ;
33800
33801 if (!args) SWIG_fail;
33802 swig_obj[0] = args;
33803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33806 }
33807 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33808 {
33809 PyThreadState* __tstate = wxPyBeginAllowThreads();
33810 (arg1)->OnLeave();
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 resultobj = SWIG_Py_Void();
33815 return resultobj;
33816 fail:
33817 return NULL;
33818 }
33819
33820
33821 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33822 PyObject *resultobj = 0;
33823 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33824 int arg2 ;
33825 int arg3 ;
33826 bool result;
33827 void *argp1 = 0 ;
33828 int res1 = 0 ;
33829 int val2 ;
33830 int ecode2 = 0 ;
33831 int val3 ;
33832 int ecode3 = 0 ;
33833 PyObject * obj0 = 0 ;
33834 PyObject * obj1 = 0 ;
33835 PyObject * obj2 = 0 ;
33836 char * kwnames[] = {
33837 (char *) "self",(char *) "x",(char *) "y", NULL
33838 };
33839
33840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33844 }
33845 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33846 ecode2 = SWIG_AsVal_int(obj1, &val2);
33847 if (!SWIG_IsOK(ecode2)) {
33848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33849 }
33850 arg2 = static_cast< int >(val2);
33851 ecode3 = SWIG_AsVal_int(obj2, &val3);
33852 if (!SWIG_IsOK(ecode3)) {
33853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33854 }
33855 arg3 = static_cast< int >(val3);
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 result = (bool)(arg1)->OnDrop(arg2,arg3);
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 {
33863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33864 }
33865 return resultobj;
33866 fail:
33867 return NULL;
33868 }
33869
33870
33871 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33872 PyObject *resultobj = 0;
33873 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33874 int arg2 ;
33875 int arg3 ;
33876 wxDragResult arg4 ;
33877 wxDragResult result;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 int val2 ;
33881 int ecode2 = 0 ;
33882 int val3 ;
33883 int ecode3 = 0 ;
33884 int val4 ;
33885 int ecode4 = 0 ;
33886 PyObject * obj0 = 0 ;
33887 PyObject * obj1 = 0 ;
33888 PyObject * obj2 = 0 ;
33889 PyObject * obj3 = 0 ;
33890 char * kwnames[] = {
33891 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33892 };
33893
33894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33896 if (!SWIG_IsOK(res1)) {
33897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33898 }
33899 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33900 ecode2 = SWIG_AsVal_int(obj1, &val2);
33901 if (!SWIG_IsOK(ecode2)) {
33902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33903 }
33904 arg2 = static_cast< int >(val2);
33905 ecode3 = SWIG_AsVal_int(obj2, &val3);
33906 if (!SWIG_IsOK(ecode3)) {
33907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33908 }
33909 arg3 = static_cast< int >(val3);
33910 ecode4 = SWIG_AsVal_int(obj3, &val4);
33911 if (!SWIG_IsOK(ecode4)) {
33912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33913 }
33914 arg4 = static_cast< wxDragResult >(val4);
33915 {
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33918 wxPyEndAllowThreads(__tstate);
33919 if (PyErr_Occurred()) SWIG_fail;
33920 }
33921 resultobj = SWIG_From_int(static_cast< int >(result));
33922 return resultobj;
33923 fail:
33924 return NULL;
33925 }
33926
33927
33928 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33929 PyObject *obj;
33930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33931 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33932 return SWIG_Py_Void();
33933 }
33934
33935 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33936 return SWIG_Python_InitShadowInstance(args);
33937 }
33938
33939 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33940 PyObject *resultobj = 0;
33941 wxClipboard *result = 0 ;
33942
33943 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 result = (wxClipboard *)new wxClipboard();
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33951 return resultobj;
33952 fail:
33953 return NULL;
33954 }
33955
33956
33957 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33958 PyObject *resultobj = 0;
33959 wxClipboard *arg1 = (wxClipboard *) 0 ;
33960 void *argp1 = 0 ;
33961 int res1 = 0 ;
33962 PyObject *swig_obj[1] ;
33963
33964 if (!args) SWIG_fail;
33965 swig_obj[0] = args;
33966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33969 }
33970 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33971 {
33972 PyThreadState* __tstate = wxPyBeginAllowThreads();
33973 delete arg1;
33974
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_Py_Void();
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33986 PyObject *resultobj = 0;
33987 wxClipboard *arg1 = (wxClipboard *) 0 ;
33988 bool result;
33989 void *argp1 = 0 ;
33990 int res1 = 0 ;
33991 PyObject *swig_obj[1] ;
33992
33993 if (!args) SWIG_fail;
33994 swig_obj[0] = args;
33995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33998 }
33999 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 result = (bool)(arg1)->Open();
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 {
34007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34008 }
34009 return resultobj;
34010 fail:
34011 return NULL;
34012 }
34013
34014
34015 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34016 PyObject *resultobj = 0;
34017 wxClipboard *arg1 = (wxClipboard *) 0 ;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 PyObject *swig_obj[1] ;
34021
34022 if (!args) SWIG_fail;
34023 swig_obj[0] = args;
34024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34027 }
34028 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 (arg1)->Close();
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_Py_Void();
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34043 PyObject *resultobj = 0;
34044 wxClipboard *arg1 = (wxClipboard *) 0 ;
34045 bool result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34055 }
34056 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 {
34064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34065 }
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34073 PyObject *resultobj = 0;
34074 wxClipboard *arg1 = (wxClipboard *) 0 ;
34075 wxDataObject *arg2 = (wxDataObject *) 0 ;
34076 bool result;
34077 void *argp1 = 0 ;
34078 int res1 = 0 ;
34079 int res2 = 0 ;
34080 PyObject * obj0 = 0 ;
34081 PyObject * obj1 = 0 ;
34082 char * kwnames[] = {
34083 (char *) "self",(char *) "data", NULL
34084 };
34085
34086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34088 if (!SWIG_IsOK(res1)) {
34089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34090 }
34091 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34092 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34093 if (!SWIG_IsOK(res2)) {
34094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34095 }
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (bool)(arg1)->AddData(arg2);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 {
34103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34104 }
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34112 PyObject *resultobj = 0;
34113 wxClipboard *arg1 = (wxClipboard *) 0 ;
34114 wxDataObject *arg2 = (wxDataObject *) 0 ;
34115 bool result;
34116 void *argp1 = 0 ;
34117 int res1 = 0 ;
34118 int res2 = 0 ;
34119 PyObject * obj0 = 0 ;
34120 PyObject * obj1 = 0 ;
34121 char * kwnames[] = {
34122 (char *) "self",(char *) "data", NULL
34123 };
34124
34125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34127 if (!SWIG_IsOK(res1)) {
34128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34129 }
34130 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34131 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34132 if (!SWIG_IsOK(res2)) {
34133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34134 }
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 result = (bool)(arg1)->SetData(arg2);
34138 wxPyEndAllowThreads(__tstate);
34139 if (PyErr_Occurred()) SWIG_fail;
34140 }
34141 {
34142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34143 }
34144 return resultobj;
34145 fail:
34146 return NULL;
34147 }
34148
34149
34150 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34151 PyObject *resultobj = 0;
34152 wxClipboard *arg1 = (wxClipboard *) 0 ;
34153 wxDataFormat *arg2 = 0 ;
34154 bool result;
34155 void *argp1 = 0 ;
34156 int res1 = 0 ;
34157 void *argp2 = 0 ;
34158 int res2 = 0 ;
34159 PyObject * obj0 = 0 ;
34160 PyObject * obj1 = 0 ;
34161 char * kwnames[] = {
34162 (char *) "self",(char *) "format", NULL
34163 };
34164
34165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34167 if (!SWIG_IsOK(res1)) {
34168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34169 }
34170 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34172 if (!SWIG_IsOK(res2)) {
34173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34174 }
34175 if (!argp2) {
34176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34177 }
34178 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 {
34186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34187 }
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxClipboard *arg1 = (wxClipboard *) 0 ;
34197 wxDataObject *arg2 = 0 ;
34198 bool result;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 void *argp2 = 0 ;
34202 int res2 = 0 ;
34203 PyObject * obj0 = 0 ;
34204 PyObject * obj1 = 0 ;
34205 char * kwnames[] = {
34206 (char *) "self",(char *) "data", NULL
34207 };
34208
34209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34211 if (!SWIG_IsOK(res1)) {
34212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34213 }
34214 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34216 if (!SWIG_IsOK(res2)) {
34217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34218 }
34219 if (!argp2) {
34220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34221 }
34222 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = (bool)(arg1)->GetData(*arg2);
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 {
34230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34231 }
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxClipboard *arg1 = (wxClipboard *) 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 PyObject *swig_obj[1] ;
34244
34245 if (!args) SWIG_fail;
34246 swig_obj[0] = args;
34247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34250 }
34251 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 (arg1)->Clear();
34255 wxPyEndAllowThreads(__tstate);
34256 if (PyErr_Occurred()) SWIG_fail;
34257 }
34258 resultobj = SWIG_Py_Void();
34259 return resultobj;
34260 fail:
34261 return NULL;
34262 }
34263
34264
34265 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34266 PyObject *resultobj = 0;
34267 wxClipboard *arg1 = (wxClipboard *) 0 ;
34268 bool result;
34269 void *argp1 = 0 ;
34270 int res1 = 0 ;
34271 PyObject *swig_obj[1] ;
34272
34273 if (!args) SWIG_fail;
34274 swig_obj[0] = args;
34275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34278 }
34279 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 result = (bool)(arg1)->Flush();
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 {
34287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34288 }
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj = 0;
34297 wxClipboard *arg1 = (wxClipboard *) 0 ;
34298 bool arg2 = (bool) true ;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 bool val2 ;
34302 int ecode2 = 0 ;
34303 PyObject * obj0 = 0 ;
34304 PyObject * obj1 = 0 ;
34305 char * kwnames[] = {
34306 (char *) "self",(char *) "primary", NULL
34307 };
34308
34309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34313 }
34314 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34315 if (obj1) {
34316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34317 if (!SWIG_IsOK(ecode2)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34319 }
34320 arg2 = static_cast< bool >(val2);
34321 }
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->UsePrimarySelection(arg2);
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 resultobj = SWIG_Py_Void();
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34336 PyObject *resultobj = 0;
34337 wxClipboard *result = 0 ;
34338
34339 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34340 {
34341 PyThreadState* __tstate = wxPyBeginAllowThreads();
34342 result = (wxClipboard *)wxClipboard::Get();
34343 wxPyEndAllowThreads(__tstate);
34344 if (PyErr_Occurred()) SWIG_fail;
34345 }
34346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34347 return resultobj;
34348 fail:
34349 return NULL;
34350 }
34351
34352
34353 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34354 PyObject *obj;
34355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34356 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34357 return SWIG_Py_Void();
34358 }
34359
34360 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34361 return SWIG_Python_InitShadowInstance(args);
34362 }
34363
34364 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34365 PyObject *resultobj = 0;
34366 wxClipboard *arg1 = (wxClipboard *) NULL ;
34367 wxClipboardLocker *result = 0 ;
34368 void *argp1 = 0 ;
34369 int res1 = 0 ;
34370 PyObject * obj0 = 0 ;
34371 char * kwnames[] = {
34372 (char *) "clipboard", NULL
34373 };
34374
34375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34376 if (obj0) {
34377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34378 if (!SWIG_IsOK(res1)) {
34379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34380 }
34381 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34382 }
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34399 void *argp1 = 0 ;
34400 int res1 = 0 ;
34401 PyObject *swig_obj[1] ;
34402
34403 if (!args) SWIG_fail;
34404 swig_obj[0] = args;
34405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34406 if (!SWIG_IsOK(res1)) {
34407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34408 }
34409 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34410 {
34411 PyThreadState* __tstate = wxPyBeginAllowThreads();
34412 delete arg1;
34413
34414 wxPyEndAllowThreads(__tstate);
34415 if (PyErr_Occurred()) SWIG_fail;
34416 }
34417 resultobj = SWIG_Py_Void();
34418 return resultobj;
34419 fail:
34420 return NULL;
34421 }
34422
34423
34424 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34425 PyObject *resultobj = 0;
34426 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34427 bool result;
34428 void *argp1 = 0 ;
34429 int res1 = 0 ;
34430 PyObject *swig_obj[1] ;
34431
34432 if (!args) SWIG_fail;
34433 swig_obj[0] = args;
34434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34435 if (!SWIG_IsOK(res1)) {
34436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34437 }
34438 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 result = (bool)wxClipboardLocker___nonzero__(arg1);
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 {
34446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34447 }
34448 return resultobj;
34449 fail:
34450 return NULL;
34451 }
34452
34453
34454 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34455 PyObject *obj;
34456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34457 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34458 return SWIG_Py_Void();
34459 }
34460
34461 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 return SWIG_Python_InitShadowInstance(args);
34463 }
34464
34465 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34466 PyObject *resultobj = 0;
34467 int arg1 = (int) 0 ;
34468 int arg2 = (int) 0 ;
34469 int arg3 = (int) 0 ;
34470 int arg4 = (int) 0 ;
34471 wxVideoMode *result = 0 ;
34472 int val1 ;
34473 int ecode1 = 0 ;
34474 int val2 ;
34475 int ecode2 = 0 ;
34476 int val3 ;
34477 int ecode3 = 0 ;
34478 int val4 ;
34479 int ecode4 = 0 ;
34480 PyObject * obj0 = 0 ;
34481 PyObject * obj1 = 0 ;
34482 PyObject * obj2 = 0 ;
34483 PyObject * obj3 = 0 ;
34484 char * kwnames[] = {
34485 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34486 };
34487
34488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34489 if (obj0) {
34490 ecode1 = SWIG_AsVal_int(obj0, &val1);
34491 if (!SWIG_IsOK(ecode1)) {
34492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34493 }
34494 arg1 = static_cast< int >(val1);
34495 }
34496 if (obj1) {
34497 ecode2 = SWIG_AsVal_int(obj1, &val2);
34498 if (!SWIG_IsOK(ecode2)) {
34499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34500 }
34501 arg2 = static_cast< int >(val2);
34502 }
34503 if (obj2) {
34504 ecode3 = SWIG_AsVal_int(obj2, &val3);
34505 if (!SWIG_IsOK(ecode3)) {
34506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34507 }
34508 arg3 = static_cast< int >(val3);
34509 }
34510 if (obj3) {
34511 ecode4 = SWIG_AsVal_int(obj3, &val4);
34512 if (!SWIG_IsOK(ecode4)) {
34513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34514 }
34515 arg4 = static_cast< int >(val4);
34516 }
34517 {
34518 PyThreadState* __tstate = wxPyBeginAllowThreads();
34519 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34531 PyObject *resultobj = 0;
34532 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34542 }
34543 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 delete arg1;
34547
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 resultobj = SWIG_Py_Void();
34552 return resultobj;
34553 fail:
34554 return NULL;
34555 }
34556
34557
34558 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj = 0;
34560 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34561 wxVideoMode *arg2 = 0 ;
34562 bool result;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 void *argp2 = 0 ;
34566 int res2 = 0 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char * kwnames[] = {
34570 (char *) "self",(char *) "other", NULL
34571 };
34572
34573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34577 }
34578 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34580 if (!SWIG_IsOK(res2)) {
34581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34582 }
34583 if (!argp2) {
34584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34585 }
34586 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34587 {
34588 PyThreadState* __tstate = wxPyBeginAllowThreads();
34589 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 {
34594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34595 }
34596 return resultobj;
34597 fail:
34598 return NULL;
34599 }
34600
34601
34602 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34603 PyObject *resultobj = 0;
34604 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34605 int result;
34606 void *argp1 = 0 ;
34607 int res1 = 0 ;
34608 PyObject *swig_obj[1] ;
34609
34610 if (!args) SWIG_fail;
34611 swig_obj[0] = args;
34612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34615 }
34616 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34617 {
34618 PyThreadState* __tstate = wxPyBeginAllowThreads();
34619 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 resultobj = SWIG_From_int(static_cast< int >(result));
34624 return resultobj;
34625 fail:
34626 return NULL;
34627 }
34628
34629
34630 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34631 PyObject *resultobj = 0;
34632 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34633 int result;
34634 void *argp1 = 0 ;
34635 int res1 = 0 ;
34636 PyObject *swig_obj[1] ;
34637
34638 if (!args) SWIG_fail;
34639 swig_obj[0] = args;
34640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34641 if (!SWIG_IsOK(res1)) {
34642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34643 }
34644 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34645 {
34646 PyThreadState* __tstate = wxPyBeginAllowThreads();
34647 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 resultobj = SWIG_From_int(static_cast< int >(result));
34652 return resultobj;
34653 fail:
34654 return NULL;
34655 }
34656
34657
34658 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34659 PyObject *resultobj = 0;
34660 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34661 int result;
34662 void *argp1 = 0 ;
34663 int res1 = 0 ;
34664 PyObject *swig_obj[1] ;
34665
34666 if (!args) SWIG_fail;
34667 swig_obj[0] = args;
34668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34671 }
34672 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 resultobj = SWIG_From_int(static_cast< int >(result));
34680 return resultobj;
34681 fail:
34682 return NULL;
34683 }
34684
34685
34686 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34687 PyObject *resultobj = 0;
34688 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34689 bool result;
34690 void *argp1 = 0 ;
34691 int res1 = 0 ;
34692 PyObject *swig_obj[1] ;
34693
34694 if (!args) SWIG_fail;
34695 swig_obj[0] = args;
34696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34697 if (!SWIG_IsOK(res1)) {
34698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34699 }
34700 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34701 {
34702 PyThreadState* __tstate = wxPyBeginAllowThreads();
34703 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34704 wxPyEndAllowThreads(__tstate);
34705 if (PyErr_Occurred()) SWIG_fail;
34706 }
34707 {
34708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34709 }
34710 return resultobj;
34711 fail:
34712 return NULL;
34713 }
34714
34715
34716 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34717 PyObject *resultobj = 0;
34718 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34719 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34720 bool result;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 void *argp2 = 0 ;
34724 int res2 = 0 ;
34725 PyObject * obj0 = 0 ;
34726 PyObject * obj1 = 0 ;
34727 char * kwnames[] = {
34728 (char *) "self",(char *) "other", NULL
34729 };
34730
34731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34735 }
34736 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34738 if (!SWIG_IsOK(res2)) {
34739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34740 }
34741 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34745 wxPyEndAllowThreads(__tstate);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 }
34748 {
34749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34750 }
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = 0;
34759 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34760 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34761 bool result;
34762 void *argp1 = 0 ;
34763 int res1 = 0 ;
34764 void *argp2 = 0 ;
34765 int res2 = 0 ;
34766 PyObject * obj0 = 0 ;
34767 PyObject * obj1 = 0 ;
34768 char * kwnames[] = {
34769 (char *) "self",(char *) "other", NULL
34770 };
34771
34772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34774 if (!SWIG_IsOK(res1)) {
34775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34776 }
34777 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34779 if (!SWIG_IsOK(res2)) {
34780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34781 }
34782 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34786 wxPyEndAllowThreads(__tstate);
34787 if (PyErr_Occurred()) SWIG_fail;
34788 }
34789 {
34790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34791 }
34792 return resultobj;
34793 fail:
34794 return NULL;
34795 }
34796
34797
34798 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34799 PyObject *resultobj = 0;
34800 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34801 int arg2 ;
34802 void *argp1 = 0 ;
34803 int res1 = 0 ;
34804 int val2 ;
34805 int ecode2 = 0 ;
34806 PyObject *swig_obj[2] ;
34807
34808 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34810 if (!SWIG_IsOK(res1)) {
34811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34812 }
34813 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34814 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34815 if (!SWIG_IsOK(ecode2)) {
34816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34817 }
34818 arg2 = static_cast< int >(val2);
34819 if (arg1) (arg1)->w = arg2;
34820
34821 resultobj = SWIG_Py_Void();
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34829 PyObject *resultobj = 0;
34830 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34831 int result;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 PyObject *swig_obj[1] ;
34835
34836 if (!args) SWIG_fail;
34837 swig_obj[0] = args;
34838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34839 if (!SWIG_IsOK(res1)) {
34840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34841 }
34842 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34843 result = (int) ((arg1)->w);
34844 resultobj = SWIG_From_int(static_cast< int >(result));
34845 return resultobj;
34846 fail:
34847 return NULL;
34848 }
34849
34850
34851 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34852 PyObject *resultobj = 0;
34853 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34854 int arg2 ;
34855 void *argp1 = 0 ;
34856 int res1 = 0 ;
34857 int val2 ;
34858 int ecode2 = 0 ;
34859 PyObject *swig_obj[2] ;
34860
34861 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34863 if (!SWIG_IsOK(res1)) {
34864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34865 }
34866 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34867 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34868 if (!SWIG_IsOK(ecode2)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34870 }
34871 arg2 = static_cast< int >(val2);
34872 if (arg1) (arg1)->h = arg2;
34873
34874 resultobj = SWIG_Py_Void();
34875 return resultobj;
34876 fail:
34877 return NULL;
34878 }
34879
34880
34881 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34882 PyObject *resultobj = 0;
34883 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34884 int result;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 PyObject *swig_obj[1] ;
34888
34889 if (!args) SWIG_fail;
34890 swig_obj[0] = args;
34891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34892 if (!SWIG_IsOK(res1)) {
34893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34894 }
34895 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34896 result = (int) ((arg1)->h);
34897 resultobj = SWIG_From_int(static_cast< int >(result));
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34905 PyObject *resultobj = 0;
34906 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34907 int arg2 ;
34908 void *argp1 = 0 ;
34909 int res1 = 0 ;
34910 int val2 ;
34911 int ecode2 = 0 ;
34912 PyObject *swig_obj[2] ;
34913
34914 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34916 if (!SWIG_IsOK(res1)) {
34917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34918 }
34919 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34920 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34921 if (!SWIG_IsOK(ecode2)) {
34922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34923 }
34924 arg2 = static_cast< int >(val2);
34925 if (arg1) (arg1)->bpp = arg2;
34926
34927 resultobj = SWIG_Py_Void();
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34935 PyObject *resultobj = 0;
34936 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34937 int result;
34938 void *argp1 = 0 ;
34939 int res1 = 0 ;
34940 PyObject *swig_obj[1] ;
34941
34942 if (!args) SWIG_fail;
34943 swig_obj[0] = args;
34944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34945 if (!SWIG_IsOK(res1)) {
34946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34947 }
34948 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34949 result = (int) ((arg1)->bpp);
34950 resultobj = SWIG_From_int(static_cast< int >(result));
34951 return resultobj;
34952 fail:
34953 return NULL;
34954 }
34955
34956
34957 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34958 PyObject *resultobj = 0;
34959 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34960 int arg2 ;
34961 void *argp1 = 0 ;
34962 int res1 = 0 ;
34963 int val2 ;
34964 int ecode2 = 0 ;
34965 PyObject *swig_obj[2] ;
34966
34967 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34969 if (!SWIG_IsOK(res1)) {
34970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34971 }
34972 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34973 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34974 if (!SWIG_IsOK(ecode2)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34976 }
34977 arg2 = static_cast< int >(val2);
34978 if (arg1) (arg1)->refresh = arg2;
34979
34980 resultobj = SWIG_Py_Void();
34981 return resultobj;
34982 fail:
34983 return NULL;
34984 }
34985
34986
34987 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34988 PyObject *resultobj = 0;
34989 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34990 int result;
34991 void *argp1 = 0 ;
34992 int res1 = 0 ;
34993 PyObject *swig_obj[1] ;
34994
34995 if (!args) SWIG_fail;
34996 swig_obj[0] = args;
34997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34998 if (!SWIG_IsOK(res1)) {
34999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35000 }
35001 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35002 result = (int) ((arg1)->refresh);
35003 resultobj = SWIG_From_int(static_cast< int >(result));
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35011 PyObject *obj;
35012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35013 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35014 return SWIG_Py_Void();
35015 }
35016
35017 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35018 return SWIG_Python_InitShadowInstance(args);
35019 }
35020
35021 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35022 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35023 return 1;
35024 }
35025
35026
35027 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35028 PyObject *pyobj = 0;
35029
35030 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35031 return pyobj;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 size_t arg1 = (size_t) 0 ;
35038 wxDisplay *result = 0 ;
35039 size_t val1 ;
35040 int ecode1 = 0 ;
35041 PyObject * obj0 = 0 ;
35042 char * kwnames[] = {
35043 (char *) "index", NULL
35044 };
35045
35046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35047 if (obj0) {
35048 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35049 if (!SWIG_IsOK(ecode1)) {
35050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35051 }
35052 arg1 = static_cast< size_t >(val1);
35053 }
35054 {
35055 PyThreadState* __tstate = wxPyBeginAllowThreads();
35056 result = (wxDisplay *)new wxDisplay(arg1);
35057 wxPyEndAllowThreads(__tstate);
35058 if (PyErr_Occurred()) SWIG_fail;
35059 }
35060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35068 PyObject *resultobj = 0;
35069 wxDisplay *arg1 = (wxDisplay *) 0 ;
35070 void *argp1 = 0 ;
35071 int res1 = 0 ;
35072 PyObject *swig_obj[1] ;
35073
35074 if (!args) SWIG_fail;
35075 swig_obj[0] = args;
35076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35079 }
35080 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35081 {
35082 PyThreadState* __tstate = wxPyBeginAllowThreads();
35083 delete arg1;
35084
35085 wxPyEndAllowThreads(__tstate);
35086 if (PyErr_Occurred()) SWIG_fail;
35087 }
35088 resultobj = SWIG_Py_Void();
35089 return resultobj;
35090 fail:
35091 return NULL;
35092 }
35093
35094
35095 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35096 PyObject *resultobj = 0;
35097 size_t result;
35098
35099 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (size_t)wxDisplay::GetCount();
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35114 PyObject *resultobj = 0;
35115 wxPoint *arg1 = 0 ;
35116 int result;
35117 wxPoint temp1 ;
35118 PyObject * obj0 = 0 ;
35119 char * kwnames[] = {
35120 (char *) "pt", NULL
35121 };
35122
35123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35124 {
35125 arg1 = &temp1;
35126 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35127 }
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 resultobj = SWIG_From_int(static_cast< int >(result));
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35142 PyObject *resultobj = 0;
35143 wxWindow *arg1 = (wxWindow *) 0 ;
35144 int result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 PyObject * obj0 = 0 ;
35148 char * kwnames[] = {
35149 (char *) "window", NULL
35150 };
35151
35152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35154 if (!SWIG_IsOK(res1)) {
35155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35156 }
35157 arg1 = reinterpret_cast< wxWindow * >(argp1);
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 result = (int)wxDisplay::GetFromWindow(arg1);
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 resultobj = SWIG_From_int(static_cast< int >(result));
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35172 PyObject *resultobj = 0;
35173 wxDisplay *arg1 = (wxDisplay *) 0 ;
35174 bool result;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 PyObject *swig_obj[1] ;
35178
35179 if (!args) SWIG_fail;
35180 swig_obj[0] = args;
35181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35184 }
35185 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = (bool)((wxDisplay const *)arg1)->IsOk();
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 {
35193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35194 }
35195 return resultobj;
35196 fail:
35197 return NULL;
35198 }
35199
35200
35201 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35202 PyObject *resultobj = 0;
35203 wxDisplay *arg1 = (wxDisplay *) 0 ;
35204 wxRect result;
35205 void *argp1 = 0 ;
35206 int res1 = 0 ;
35207 PyObject *swig_obj[1] ;
35208
35209 if (!args) SWIG_fail;
35210 swig_obj[0] = args;
35211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35212 if (!SWIG_IsOK(res1)) {
35213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35214 }
35215 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 result = ((wxDisplay const *)arg1)->GetGeometry();
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35230 PyObject *resultobj = 0;
35231 wxDisplay *arg1 = (wxDisplay *) 0 ;
35232 wxRect result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 PyObject *swig_obj[1] ;
35236
35237 if (!args) SWIG_fail;
35238 swig_obj[0] = args;
35239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35242 }
35243 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = ((wxDisplay const *)arg1)->GetClientArea();
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 PyObject *resultobj = 0;
35259 wxDisplay *arg1 = (wxDisplay *) 0 ;
35260 wxString result;
35261 void *argp1 = 0 ;
35262 int res1 = 0 ;
35263 PyObject *swig_obj[1] ;
35264
35265 if (!args) SWIG_fail;
35266 swig_obj[0] = args;
35267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35268 if (!SWIG_IsOK(res1)) {
35269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35270 }
35271 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = ((wxDisplay const *)arg1)->GetName();
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 {
35279 #if wxUSE_UNICODE
35280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35281 #else
35282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35283 #endif
35284 }
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35292 PyObject *resultobj = 0;
35293 wxDisplay *arg1 = (wxDisplay *) 0 ;
35294 bool result;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 PyObject *swig_obj[1] ;
35298
35299 if (!args) SWIG_fail;
35300 swig_obj[0] = args;
35301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35304 }
35305 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 {
35313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35314 }
35315 return resultobj;
35316 fail:
35317 return NULL;
35318 }
35319
35320
35321 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35322 PyObject *resultobj = 0;
35323 wxDisplay *arg1 = (wxDisplay *) 0 ;
35324 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35325 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35326 PyObject *result = 0 ;
35327 void *argp1 = 0 ;
35328 int res1 = 0 ;
35329 void *argp2 = 0 ;
35330 int res2 = 0 ;
35331 PyObject * obj0 = 0 ;
35332 PyObject * obj1 = 0 ;
35333 char * kwnames[] = {
35334 (char *) "self",(char *) "mode", NULL
35335 };
35336
35337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35341 }
35342 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35343 if (obj1) {
35344 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35345 if (!SWIG_IsOK(res2)) {
35346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35347 }
35348 if (!argp2) {
35349 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35350 }
35351 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35352 }
35353 {
35354 PyThreadState* __tstate = wxPyBeginAllowThreads();
35355 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35356 wxPyEndAllowThreads(__tstate);
35357 if (PyErr_Occurred()) SWIG_fail;
35358 }
35359 resultobj = result;
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35367 PyObject *resultobj = 0;
35368 wxDisplay *arg1 = (wxDisplay *) 0 ;
35369 wxVideoMode result;
35370 void *argp1 = 0 ;
35371 int res1 = 0 ;
35372 PyObject *swig_obj[1] ;
35373
35374 if (!args) SWIG_fail;
35375 swig_obj[0] = args;
35376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35377 if (!SWIG_IsOK(res1)) {
35378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35379 }
35380 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35381 {
35382 PyThreadState* __tstate = wxPyBeginAllowThreads();
35383 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35384 wxPyEndAllowThreads(__tstate);
35385 if (PyErr_Occurred()) SWIG_fail;
35386 }
35387 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj = 0;
35396 wxDisplay *arg1 = (wxDisplay *) 0 ;
35397 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35398 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35399 bool result;
35400 void *argp1 = 0 ;
35401 int res1 = 0 ;
35402 void *argp2 = 0 ;
35403 int res2 = 0 ;
35404 PyObject * obj0 = 0 ;
35405 PyObject * obj1 = 0 ;
35406 char * kwnames[] = {
35407 (char *) "self",(char *) "mode", NULL
35408 };
35409
35410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35412 if (!SWIG_IsOK(res1)) {
35413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35414 }
35415 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35416 if (obj1) {
35417 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35418 if (!SWIG_IsOK(res2)) {
35419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35420 }
35421 if (!argp2) {
35422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35423 }
35424 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35425 }
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35429 wxPyEndAllowThreads(__tstate);
35430 if (PyErr_Occurred()) SWIG_fail;
35431 }
35432 {
35433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35434 }
35435 return resultobj;
35436 fail:
35437 return NULL;
35438 }
35439
35440
35441 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35442 PyObject *resultobj = 0;
35443 wxDisplay *arg1 = (wxDisplay *) 0 ;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 PyObject *swig_obj[1] ;
35447
35448 if (!args) SWIG_fail;
35449 swig_obj[0] = args;
35450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35453 }
35454 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 wxDisplay_ResetMode(arg1);
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 resultobj = SWIG_Py_Void();
35462 return resultobj;
35463 fail:
35464 return NULL;
35465 }
35466
35467
35468 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35469 PyObject *obj;
35470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35471 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35472 return SWIG_Py_Void();
35473 }
35474
35475 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35476 return SWIG_Python_InitShadowInstance(args);
35477 }
35478
35479 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35480 PyObject *resultobj = 0;
35481 wxStandardPaths *result = 0 ;
35482
35483 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = (wxStandardPaths *)wxStandardPaths_Get();
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35498 PyObject *resultobj = 0;
35499 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35500 wxString result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35510 }
35511 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 #if wxUSE_UNICODE
35520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35521 #else
35522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35523 #endif
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35532 PyObject *resultobj = 0;
35533 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35534 wxString result;
35535 void *argp1 = 0 ;
35536 int res1 = 0 ;
35537 PyObject *swig_obj[1] ;
35538
35539 if (!args) SWIG_fail;
35540 swig_obj[0] = args;
35541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35544 }
35545 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 #if wxUSE_UNICODE
35554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35555 #else
35556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35557 #endif
35558 }
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35566 PyObject *resultobj = 0;
35567 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35568 wxString result;
35569 void *argp1 = 0 ;
35570 int res1 = 0 ;
35571 PyObject *swig_obj[1] ;
35572
35573 if (!args) SWIG_fail;
35574 swig_obj[0] = args;
35575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 #if wxUSE_UNICODE
35588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35589 #else
35590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35591 #endif
35592 }
35593 return resultobj;
35594 fail:
35595 return NULL;
35596 }
35597
35598
35599 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35600 PyObject *resultobj = 0;
35601 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35602 wxString result;
35603 void *argp1 = 0 ;
35604 int res1 = 0 ;
35605 PyObject *swig_obj[1] ;
35606
35607 if (!args) SWIG_fail;
35608 swig_obj[0] = args;
35609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35610 if (!SWIG_IsOK(res1)) {
35611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35612 }
35613 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 #if wxUSE_UNICODE
35622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35623 #else
35624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35625 #endif
35626 }
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35634 PyObject *resultobj = 0;
35635 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35636 wxString result;
35637 void *argp1 = 0 ;
35638 int res1 = 0 ;
35639 PyObject *swig_obj[1] ;
35640
35641 if (!args) SWIG_fail;
35642 swig_obj[0] = args;
35643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35646 }
35647 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 {
35655 #if wxUSE_UNICODE
35656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35657 #else
35658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35659 #endif
35660 }
35661 return resultobj;
35662 fail:
35663 return NULL;
35664 }
35665
35666
35667 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35668 PyObject *resultobj = 0;
35669 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35670 wxString result;
35671 void *argp1 = 0 ;
35672 int res1 = 0 ;
35673 PyObject *swig_obj[1] ;
35674
35675 if (!args) SWIG_fail;
35676 swig_obj[0] = args;
35677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35678 if (!SWIG_IsOK(res1)) {
35679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35680 }
35681 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 #if wxUSE_UNICODE
35690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35691 #else
35692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35693 #endif
35694 }
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35702 PyObject *resultobj = 0;
35703 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35704 wxString result;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 PyObject *swig_obj[1] ;
35708
35709 if (!args) SWIG_fail;
35710 swig_obj[0] = args;
35711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35712 if (!SWIG_IsOK(res1)) {
35713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35714 }
35715 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35716 {
35717 PyThreadState* __tstate = wxPyBeginAllowThreads();
35718 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 {
35723 #if wxUSE_UNICODE
35724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35725 #else
35726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35727 #endif
35728 }
35729 return resultobj;
35730 fail:
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35736 PyObject *resultobj = 0;
35737 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35738 wxString result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 PyObject *swig_obj[1] ;
35742
35743 if (!args) SWIG_fail;
35744 swig_obj[0] = args;
35745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35746 if (!SWIG_IsOK(res1)) {
35747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35748 }
35749 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 {
35757 #if wxUSE_UNICODE
35758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35759 #else
35760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35761 #endif
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35770 PyObject *resultobj = 0;
35771 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35772 wxString *arg2 = 0 ;
35773 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35774 wxString result;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 bool temp2 = false ;
35778 int val3 ;
35779 int ecode3 = 0 ;
35780 PyObject * obj0 = 0 ;
35781 PyObject * obj1 = 0 ;
35782 PyObject * obj2 = 0 ;
35783 char * kwnames[] = {
35784 (char *) "self",(char *) "lang",(char *) "category", NULL
35785 };
35786
35787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35789 if (!SWIG_IsOK(res1)) {
35790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35791 }
35792 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35793 {
35794 arg2 = wxString_in_helper(obj1);
35795 if (arg2 == NULL) SWIG_fail;
35796 temp2 = true;
35797 }
35798 if (obj2) {
35799 ecode3 = SWIG_AsVal_int(obj2, &val3);
35800 if (!SWIG_IsOK(ecode3)) {
35801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35802 }
35803 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35804 }
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 {
35812 #if wxUSE_UNICODE
35813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35814 #else
35815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35816 #endif
35817 }
35818 {
35819 if (temp2)
35820 delete arg2;
35821 }
35822 return resultobj;
35823 fail:
35824 {
35825 if (temp2)
35826 delete arg2;
35827 }
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35833 PyObject *resultobj = 0;
35834 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35835 wxString result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 PyObject *swig_obj[1] ;
35839
35840 if (!args) SWIG_fail;
35841 swig_obj[0] = args;
35842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35843 if (!SWIG_IsOK(res1)) {
35844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35845 }
35846 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35847 {
35848 PyThreadState* __tstate = wxPyBeginAllowThreads();
35849 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35850 wxPyEndAllowThreads(__tstate);
35851 if (PyErr_Occurred()) SWIG_fail;
35852 }
35853 {
35854 #if wxUSE_UNICODE
35855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35856 #else
35857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35858 #endif
35859 }
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj = 0;
35868 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35869 wxString *arg2 = 0 ;
35870 void *argp1 = 0 ;
35871 int res1 = 0 ;
35872 bool temp2 = false ;
35873 PyObject * obj0 = 0 ;
35874 PyObject * obj1 = 0 ;
35875 char * kwnames[] = {
35876 (char *) "self",(char *) "prefix", NULL
35877 };
35878
35879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35881 if (!SWIG_IsOK(res1)) {
35882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35883 }
35884 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35885 {
35886 arg2 = wxString_in_helper(obj1);
35887 if (arg2 == NULL) SWIG_fail;
35888 temp2 = true;
35889 }
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35893 wxPyEndAllowThreads(__tstate);
35894 if (PyErr_Occurred()) SWIG_fail;
35895 }
35896 resultobj = SWIG_Py_Void();
35897 {
35898 if (temp2)
35899 delete arg2;
35900 }
35901 return resultobj;
35902 fail:
35903 {
35904 if (temp2)
35905 delete arg2;
35906 }
35907 return NULL;
35908 }
35909
35910
35911 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35912 PyObject *resultobj = 0;
35913 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35914 wxString result;
35915 void *argp1 = 0 ;
35916 int res1 = 0 ;
35917 PyObject *swig_obj[1] ;
35918
35919 if (!args) SWIG_fail;
35920 swig_obj[0] = args;
35921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35922 if (!SWIG_IsOK(res1)) {
35923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35924 }
35925 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35926 {
35927 PyThreadState* __tstate = wxPyBeginAllowThreads();
35928 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35929 wxPyEndAllowThreads(__tstate);
35930 if (PyErr_Occurred()) SWIG_fail;
35931 }
35932 {
35933 #if wxUSE_UNICODE
35934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35935 #else
35936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35937 #endif
35938 }
35939 return resultobj;
35940 fail:
35941 return NULL;
35942 }
35943
35944
35945 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35946 PyObject *obj;
35947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35948 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35949 return SWIG_Py_Void();
35950 }
35951
35952 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35953 PyObject *resultobj = 0;
35954 wxEventType arg1 ;
35955 wxPowerEvent *result = 0 ;
35956 int val1 ;
35957 int ecode1 = 0 ;
35958 PyObject * obj0 = 0 ;
35959 char * kwnames[] = {
35960 (char *) "evtType", NULL
35961 };
35962
35963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
35964 ecode1 = SWIG_AsVal_int(obj0, &val1);
35965 if (!SWIG_IsOK(ecode1)) {
35966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
35967 }
35968 arg1 = static_cast< wxEventType >(val1);
35969 {
35970 PyThreadState* __tstate = wxPyBeginAllowThreads();
35971 result = (wxPowerEvent *)new wxPowerEvent(arg1);
35972 wxPyEndAllowThreads(__tstate);
35973 if (PyErr_Occurred()) SWIG_fail;
35974 }
35975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *resultobj = 0;
35984 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
35985 void *argp1 = 0 ;
35986 int res1 = 0 ;
35987 PyObject *swig_obj[1] ;
35988
35989 if (!args) SWIG_fail;
35990 swig_obj[0] = args;
35991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
35994 }
35995 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 (arg1)->Veto();
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 resultobj = SWIG_Py_Void();
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36010 PyObject *resultobj = 0;
36011 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36012 bool result;
36013 void *argp1 = 0 ;
36014 int res1 = 0 ;
36015 PyObject *swig_obj[1] ;
36016
36017 if (!args) SWIG_fail;
36018 swig_obj[0] = args;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36022 }
36023 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 {
36031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36032 }
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36040 PyObject *obj;
36041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36042 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36043 return SWIG_Py_Void();
36044 }
36045
36046 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 return SWIG_Python_InitShadowInstance(args);
36048 }
36049
36050 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36051 PyObject *resultobj = 0;
36052 wxPowerType result;
36053
36054 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36055 {
36056 PyThreadState* __tstate = wxPyBeginAllowThreads();
36057 result = (wxPowerType)wxGetPowerType();
36058 wxPyEndAllowThreads(__tstate);
36059 if (PyErr_Occurred()) SWIG_fail;
36060 }
36061 resultobj = SWIG_From_int(static_cast< int >(result));
36062 return resultobj;
36063 fail:
36064 return NULL;
36065 }
36066
36067
36068 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36069 PyObject *resultobj = 0;
36070 wxBatteryState result;
36071
36072 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36073 {
36074 PyThreadState* __tstate = wxPyBeginAllowThreads();
36075 result = (wxBatteryState)wxGetBatteryState();
36076 wxPyEndAllowThreads(__tstate);
36077 if (PyErr_Occurred()) SWIG_fail;
36078 }
36079 resultobj = SWIG_From_int(static_cast< int >(result));
36080 return resultobj;
36081 fail:
36082 return NULL;
36083 }
36084
36085
36086 static PyMethodDef SwigMethods[] = {
36087 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36088 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36090 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36091 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36092 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36094 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36095 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36098 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36099 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36100 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36101 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36102 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36103 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36104 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36106 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36107 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36109 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36110 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36111 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36112 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36113 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36114 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36116 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36117 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36118 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36119 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36121 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36122 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36123 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36124 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36125 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36126 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36127 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36128 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36129 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36130 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36131 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36132 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36133 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36134 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36135 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36136 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36137 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36138 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36139 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36140 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36141 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36142 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36143 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36144 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36145 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36146 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36147 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36148 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36149 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36150 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36151 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36152 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36154 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36156 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36157 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36158 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36161 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36163 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36164 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36165 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36166 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36167 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36168 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36169 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36170 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36171 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36172 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36173 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36174 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36175 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36178 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36179 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36185 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36186 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36187 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36188 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36189 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36190 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36191 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36192 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36193 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36194 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36195 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36197 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36198 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36199 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36200 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36203 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36204 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36206 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36207 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36208 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36209 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36210 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36211 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36212 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36213 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36214 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36217 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36220 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36221 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36222 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36223 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36224 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36226 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36227 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36228 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36230 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36231 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36232 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36233 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36234 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36235 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36236 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36237 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36238 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36239 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36240 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36241 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36242 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36243 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36245 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36248 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36249 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36253 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36254 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36256 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36257 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36258 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36260 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36261 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36263 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36264 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36265 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36267 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36268 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36269 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36271 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36274 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36275 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36279 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36282 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36284 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36285 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36286 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36287 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36288 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36289 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36290 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36291 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36292 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36293 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36294 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36295 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36296 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36297 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36299 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36300 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36301 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36302 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36303 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36306 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36307 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36308 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36310 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36311 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36314 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36318 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36319 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36321 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36322 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36324 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36325 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36326 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36327 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36328 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36329 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36330 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36331 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36332 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36334 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36335 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36336 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36337 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36338 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36341 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36342 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36343 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36345 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36346 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36350 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36351 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36352 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36353 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36354 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36355 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36356 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36357 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36358 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36371 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36373 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36374 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36375 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36376 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36377 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36379 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36380 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36387 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36388 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36389 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36390 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36391 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36392 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36393 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36394 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36395 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36396 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36397 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36398 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36400 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36401 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36402 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36403 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36404 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36405 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36406 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36407 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36411 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36412 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36413 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36414 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36415 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36416 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36417 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36418 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36419 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36420 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36422 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36423 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36424 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36425 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36426 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36427 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36428 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36429 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36430 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36431 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36432 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36433 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36434 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36435 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36436 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36437 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36438 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36439 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36440 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36441 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36442 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36443 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36444 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36445 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36446 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36447 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36448 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36449 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36450 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36451 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36453 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36454 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36455 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36457 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36458 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36459 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36460 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36461 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36467 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36468 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36469 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36473 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36474 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36477 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36480 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36483 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36484 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36485 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36488 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36489 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36492 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36493 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36494 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36495 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36496 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36497 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36498 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36499 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36500 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36501 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36502 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36503 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36504 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36505 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36506 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36507 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36508 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36509 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36510 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36516 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36518 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36519 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36521 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36523 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36528 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36532 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36533 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36534 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36535 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36536 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36539 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36544 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36545 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36546 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36547 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36550 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36551 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36553 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36554 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36556 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36563 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36577 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36579 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36581 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36583 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36584 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36588 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36589 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36591 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36592 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36593 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36595 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36596 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36597 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36599 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36600 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36601 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36602 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36605 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36607 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36616 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36620 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36621 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36622 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36623 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36629 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36630 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36635 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36659 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36660 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36661 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36662 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36663 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36675 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36676 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36677 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36702 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36703 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36704 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36705 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36718 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36719 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36720 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36721 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36722 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36723 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36725 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36727 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36729 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36731 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36733 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36735 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36737 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36741 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36742 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36746 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36757 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36758 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36759 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36763 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36764 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36765 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36766 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36767 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36768 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36770 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36771 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36773 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36775 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36777 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36779 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36781 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36782 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36786 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36787 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36788 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36789 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36790 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36793 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36797 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36805 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36806 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36807 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36808 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36809 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36810 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36813 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36814 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36815 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36817 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36818 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36820 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36821 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36822 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36830 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36832 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36834 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36835 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36837 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36838 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36841 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36842 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36843 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36845 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36846 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36847 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36849 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36850 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36852 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36853 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36856 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36857 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36859 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36861 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36862 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36865 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36866 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36867 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36868 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36870 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36871 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36872 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36874 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36875 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36876 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36877 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36878 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36879 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36881 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36882 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36883 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36884 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36885 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36889 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36891 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36895 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36896 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36899 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36900 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36902 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36903 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36904 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36906 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36908 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36909 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36910 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36911 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36916 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36918 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36919 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36920 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36921 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36926 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36929 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36930 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36931 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36932 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36933 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36934 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36935 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36940 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36941 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36943 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36944 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36945 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36946 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36947 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36948 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36949 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36950 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36952 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36954 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36955 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36956 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36957 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36959 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36960 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36961 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36962 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36963 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36964 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36965 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36966 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36967 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36968 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36969 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36970 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36971 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36972 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36975 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36976 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36977 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36978 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36979 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36981 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36983 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36984 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36985 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36986 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36987 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36988 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36989 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36990 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36991 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36992 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36993 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36994 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36996 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36998 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36999 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37000 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37001 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37002 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37003 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37004 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37005 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37006 { NULL, NULL, 0, NULL }
37007 };
37008
37009
37010 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37011
37012 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37013 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37014 }
37015 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37016 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37017 }
37018 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37019 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37020 }
37021 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37022 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37023 }
37024 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37025 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37026 }
37027 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37028 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37029 }
37030 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37031 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37032 }
37033 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37034 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37035 }
37036 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37037 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37038 }
37039 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37040 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37041 }
37042 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37043 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37044 }
37045 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37046 return (void *)((wxEvent *) ((wxPyEvent *) x));
37047 }
37048 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37049 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37050 }
37051 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37052 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37053 }
37054 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37055 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37056 }
37057 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37058 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37059 }
37060 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37061 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37062 }
37063 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37064 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37065 }
37066 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37067 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37068 }
37069 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37070 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37071 }
37072 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37073 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37074 }
37075 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37076 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37077 }
37078 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37079 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37080 }
37081 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37082 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37083 }
37084 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37085 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37086 }
37087 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37088 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37089 }
37090 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37091 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37092 }
37093 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37094 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37095 }
37096 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37097 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37098 }
37099 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37100 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37101 }
37102 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37103 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37104 }
37105 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37106 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37107 }
37108 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37109 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37110 }
37111 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37112 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37113 }
37114 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37115 return (void *)((wxEvent *) ((wxShowEvent *) x));
37116 }
37117 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37118 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37119 }
37120 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37121 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37122 }
37123 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37124 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37125 }
37126 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37127 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37128 }
37129 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37130 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37131 }
37132 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37133 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37134 }
37135 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37136 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37137 }
37138 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37139 return (void *)((wxConfigBase *) ((wxConfig *) x));
37140 }
37141 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37142 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37143 }
37144 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37145 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37146 }
37147 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37148 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37149 }
37150 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37151 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37152 }
37153 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37154 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37155 }
37156 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37157 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37158 }
37159 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37160 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37161 }
37162 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37163 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37164 }
37165 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37166 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37167 }
37168 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37169 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37170 }
37171 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37172 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37173 }
37174 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37175 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37176 }
37177 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37178 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37179 }
37180 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37181 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37182 }
37183 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37184 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37185 }
37186 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37187 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37188 }
37189 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37190 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37191 }
37192 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37193 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37194 }
37195 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37196 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37197 }
37198 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37199 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37200 }
37201 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37202 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37203 }
37204 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37205 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37206 }
37207 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37208 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37209 }
37210 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37211 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37212 }
37213 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37214 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37215 }
37216 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37217 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37218 }
37219 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37220 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37221 }
37222 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37223 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37224 }
37225 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37226 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37227 }
37228 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37229 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37230 }
37231 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37232 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37233 }
37234 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37235 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37236 }
37237 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37238 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37239 }
37240 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37241 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37242 }
37243 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37244 return (void *)((wxObject *) ((wxSizerItem *) x));
37245 }
37246 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37248 }
37249 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37250 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37251 }
37252 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37253 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37254 }
37255 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37256 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37257 }
37258 static void *_p_wxSizerTo_p_wxObject(void *x) {
37259 return (void *)((wxObject *) ((wxSizer *) x));
37260 }
37261 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37262 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37263 }
37264 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37265 return (void *)((wxObject *) ((wxFileHistory *) x));
37266 }
37267 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37268 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37269 }
37270 static void *_p_wxEventTo_p_wxObject(void *x) {
37271 return (void *)((wxObject *) ((wxEvent *) x));
37272 }
37273 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37274 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37275 }
37276 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37277 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37278 }
37279 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37280 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37281 }
37282 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37284 }
37285 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37286 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37287 }
37288 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37289 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37290 }
37291 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37292 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37293 }
37294 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37295 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37296 }
37297 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37298 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37299 }
37300 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37301 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37302 }
37303 static void *_p_wxControlTo_p_wxObject(void *x) {
37304 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37305 }
37306 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37307 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37308 }
37309 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37310 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37311 }
37312 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37313 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37314 }
37315 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37316 return (void *)((wxObject *) ((wxFSFile *) x));
37317 }
37318 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37319 return (void *)((wxObject *) ((wxClipboard *) x));
37320 }
37321 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37322 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37323 }
37324 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37325 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37326 }
37327 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37329 }
37330 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37331 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37332 }
37333 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37334 return (void *)((wxObject *) ((wxToolTip *) x));
37335 }
37336 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37337 return (void *)((wxObject *) ((wxMenuItem *) x));
37338 }
37339 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37340 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37341 }
37342 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37343 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37344 }
37345 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37346 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37347 }
37348 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37349 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37350 }
37351 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37352 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37353 }
37354 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37355 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37356 }
37357 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37358 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37359 }
37360 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37361 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37362 }
37363 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37364 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37365 }
37366 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37367 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37368 }
37369 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37370 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37371 }
37372 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37373 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37374 }
37375 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37376 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37377 }
37378 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37379 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37380 }
37381 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37382 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37383 }
37384 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37385 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37386 }
37387 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37388 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37389 }
37390 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37391 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37392 }
37393 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37394 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37395 }
37396 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37397 return (void *)((wxObject *) ((wxImageHandler *) x));
37398 }
37399 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37400 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37401 }
37402 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37403 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37404 }
37405 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37406 return (void *)((wxObject *) ((wxEvtHandler *) x));
37407 }
37408 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37409 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37410 }
37411 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37412 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37413 }
37414 static void *_p_wxImageTo_p_wxObject(void *x) {
37415 return (void *)((wxObject *) ((wxImage *) x));
37416 }
37417 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37418 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37419 }
37420 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37421 return (void *)((wxObject *) ((wxSystemOptions *) x));
37422 }
37423 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37424 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37425 }
37426 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37427 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37428 }
37429 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37430 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37431 }
37432 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37433 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37434 }
37435 static void *_p_wxWindowTo_p_wxObject(void *x) {
37436 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37437 }
37438 static void *_p_wxMenuTo_p_wxObject(void *x) {
37439 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37440 }
37441 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37442 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37443 }
37444 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37445 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37446 }
37447 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37448 return (void *)((wxObject *) ((wxFileSystem *) x));
37449 }
37450 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37452 }
37453 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37454 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37455 }
37456 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37457 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37458 }
37459 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37460 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37461 }
37462 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37463 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37464 }
37465 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37466 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37467 }
37468 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37469 return (void *)((wxObject *) ((wxBusyInfo *) x));
37470 }
37471 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37472 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37473 }
37474 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37475 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37476 }
37477 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37478 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37479 }
37480 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37481 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37482 }
37483 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37485 }
37486 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37487 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37488 }
37489 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37490 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37491 }
37492 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37493 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37494 }
37495 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37496 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37497 }
37498 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37499 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37500 }
37501 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37502 return (void *)((wxLog *) ((wxLogBuffer *) x));
37503 }
37504 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37505 return (void *)((wxLog *) ((wxLogStderr *) x));
37506 }
37507 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37508 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37509 }
37510 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37511 return (void *)((wxLog *) ((wxLogWindow *) x));
37512 }
37513 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37514 return (void *)((wxLog *) ((wxLogChain *) x));
37515 }
37516 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37517 return (void *)((wxLog *) ((wxLogGui *) x));
37518 }
37519 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37520 return (void *)((wxLog *) ((wxPyLog *) x));
37521 }
37522 static void *_p_wxControlTo_p_wxWindow(void *x) {
37523 return (void *)((wxWindow *) ((wxControl *) x));
37524 }
37525 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37526 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37527 }
37528 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37529 return (void *)((wxWindow *) ((wxMenuBar *) x));
37530 }
37531 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37532 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37533 }
37534 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37535 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37536 }
37537 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37538 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};
37539 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37540 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37541 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37542 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37543 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37544 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37545 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37546 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37547 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37548 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37549 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37550 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37551 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37552 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37553 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37554 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37555 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37556 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37557 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37558 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37559 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37560 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37561 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37562 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37563 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37564 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37565 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37566 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37567 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37568 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37569 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37570 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37571 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37572 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37573 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37574 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37575 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37576 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37577 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37578 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37579 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37580 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37581 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37582 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37583 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37584 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37585 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37586 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37587 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37588 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37589 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37590 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37591 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37592 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37593 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37594 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37595 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37596 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37597 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37598 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37599 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37600 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37601 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37602 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37603 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37604 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37605 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37606 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37607 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37608 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37609 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37610 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37611 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37612 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37613 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37614 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37616 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37617 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37618 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37619 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37620 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37621 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37630 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37631 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37632 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37633 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37634 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37635 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37636 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37637 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37638 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37639 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37640 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37641 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37642 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37643 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37644 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37645 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37646 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37647 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37667 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37668 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37669 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37670 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37671 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37672 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37673 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37674 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37675 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37676 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37677 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37701 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37702 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37703 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37704 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37705 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37706 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37707 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37708
37709 static swig_type_info *swig_type_initial[] = {
37710 &_swigt__p_char,
37711 &_swigt__p_form_ops_t,
37712 &_swigt__p_int,
37713 &_swigt__p_unsigned_char,
37714 &_swigt__p_unsigned_int,
37715 &_swigt__p_unsigned_long,
37716 &_swigt__p_void,
37717 &_swigt__p_wxANIHandler,
37718 &_swigt__p_wxAcceleratorTable,
37719 &_swigt__p_wxActivateEvent,
37720 &_swigt__p_wxArrayString,
37721 &_swigt__p_wxBMPHandler,
37722 &_swigt__p_wxBitmap,
37723 &_swigt__p_wxBitmapDataObject,
37724 &_swigt__p_wxBoxSizer,
37725 &_swigt__p_wxBusyCursor,
37726 &_swigt__p_wxBusyInfo,
37727 &_swigt__p_wxCURHandler,
37728 &_swigt__p_wxCaret,
37729 &_swigt__p_wxChar,
37730 &_swigt__p_wxChildFocusEvent,
37731 &_swigt__p_wxClipboard,
37732 &_swigt__p_wxClipboardLocker,
37733 &_swigt__p_wxClipboardTextEvent,
37734 &_swigt__p_wxCloseEvent,
37735 &_swigt__p_wxColour,
37736 &_swigt__p_wxCommandEvent,
37737 &_swigt__p_wxConfig,
37738 &_swigt__p_wxConfigBase,
37739 &_swigt__p_wxConfigPathChanger,
37740 &_swigt__p_wxContextMenuEvent,
37741 &_swigt__p_wxControl,
37742 &_swigt__p_wxControlWithItems,
37743 &_swigt__p_wxCursor,
37744 &_swigt__p_wxCustomDataObject,
37745 &_swigt__p_wxDC,
37746 &_swigt__p_wxDataFormat,
37747 &_swigt__p_wxDataObject,
37748 &_swigt__p_wxDataObjectComposite,
37749 &_swigt__p_wxDataObjectSimple,
37750 &_swigt__p_wxDateEvent,
37751 &_swigt__p_wxDateSpan,
37752 &_swigt__p_wxDateTime,
37753 &_swigt__p_wxDateTime__TimeZone,
37754 &_swigt__p_wxDisplay,
37755 &_swigt__p_wxDisplayChangedEvent,
37756 &_swigt__p_wxDropFilesEvent,
37757 &_swigt__p_wxDuplexMode,
37758 &_swigt__p_wxEraseEvent,
37759 &_swigt__p_wxEvent,
37760 &_swigt__p_wxEvtHandler,
37761 &_swigt__p_wxFSFile,
37762 &_swigt__p_wxFileConfig,
37763 &_swigt__p_wxFileDataObject,
37764 &_swigt__p_wxFileHistory,
37765 &_swigt__p_wxFileSystem,
37766 &_swigt__p_wxFileType,
37767 &_swigt__p_wxFileTypeInfo,
37768 &_swigt__p_wxFlexGridSizer,
37769 &_swigt__p_wxFocusEvent,
37770 &_swigt__p_wxFont,
37771 &_swigt__p_wxFrame,
37772 &_swigt__p_wxGBSizerItem,
37773 &_swigt__p_wxGIFHandler,
37774 &_swigt__p_wxGridBagSizer,
37775 &_swigt__p_wxGridSizer,
37776 &_swigt__p_wxICOHandler,
37777 &_swigt__p_wxIcon,
37778 &_swigt__p_wxIconizeEvent,
37779 &_swigt__p_wxIdleEvent,
37780 &_swigt__p_wxImage,
37781 &_swigt__p_wxImageHandler,
37782 &_swigt__p_wxIndividualLayoutConstraint,
37783 &_swigt__p_wxInitDialogEvent,
37784 &_swigt__p_wxJPEGHandler,
37785 &_swigt__p_wxJoystick,
37786 &_swigt__p_wxJoystickEvent,
37787 &_swigt__p_wxKeyEvent,
37788 &_swigt__p_wxKillError,
37789 &_swigt__p_wxLayoutConstraints,
37790 &_swigt__p_wxLog,
37791 &_swigt__p_wxLogBuffer,
37792 &_swigt__p_wxLogChain,
37793 &_swigt__p_wxLogGui,
37794 &_swigt__p_wxLogNull,
37795 &_swigt__p_wxLogStderr,
37796 &_swigt__p_wxLogTextCtrl,
37797 &_swigt__p_wxLogWindow,
37798 &_swigt__p_wxMaximizeEvent,
37799 &_swigt__p_wxMemorySize,
37800 &_swigt__p_wxMenu,
37801 &_swigt__p_wxMenuBar,
37802 &_swigt__p_wxMenuEvent,
37803 &_swigt__p_wxMenuItem,
37804 &_swigt__p_wxMetafileDataObject,
37805 &_swigt__p_wxMimeTypesManager,
37806 &_swigt__p_wxMouseCaptureChangedEvent,
37807 &_swigt__p_wxMouseEvent,
37808 &_swigt__p_wxMouseState,
37809 &_swigt__p_wxMoveEvent,
37810 &_swigt__p_wxMutexGuiLocker,
37811 &_swigt__p_wxNavigationKeyEvent,
37812 &_swigt__p_wxNcPaintEvent,
37813 &_swigt__p_wxNotifyEvent,
37814 &_swigt__p_wxObject,
37815 &_swigt__p_wxOutputStream,
37816 &_swigt__p_wxPCXHandler,
37817 &_swigt__p_wxPNGHandler,
37818 &_swigt__p_wxPNMHandler,
37819 &_swigt__p_wxPaintEvent,
37820 &_swigt__p_wxPaletteChangedEvent,
37821 &_swigt__p_wxPaperSize,
37822 &_swigt__p_wxPoint,
37823 &_swigt__p_wxPowerEvent,
37824 &_swigt__p_wxProcessEvent,
37825 &_swigt__p_wxPyApp,
37826 &_swigt__p_wxPyArtProvider,
37827 &_swigt__p_wxPyBitmapDataObject,
37828 &_swigt__p_wxPyCommandEvent,
37829 &_swigt__p_wxPyDataObjectSimple,
37830 &_swigt__p_wxPyDropSource,
37831 &_swigt__p_wxPyDropTarget,
37832 &_swigt__p_wxPyEvent,
37833 &_swigt__p_wxPyFileDropTarget,
37834 &_swigt__p_wxPyImageHandler,
37835 &_swigt__p_wxPyLog,
37836 &_swigt__p_wxPyProcess,
37837 &_swigt__p_wxPySizer,
37838 &_swigt__p_wxPyTextDataObject,
37839 &_swigt__p_wxPyTextDropTarget,
37840 &_swigt__p_wxPyTimer,
37841 &_swigt__p_wxPyTipProvider,
37842 &_swigt__p_wxPyValidator,
37843 &_swigt__p_wxQueryNewPaletteEvent,
37844 &_swigt__p_wxRect,
37845 &_swigt__p_wxScrollEvent,
37846 &_swigt__p_wxScrollWinEvent,
37847 &_swigt__p_wxSetCursorEvent,
37848 &_swigt__p_wxShowEvent,
37849 &_swigt__p_wxSingleInstanceChecker,
37850 &_swigt__p_wxSize,
37851 &_swigt__p_wxSizeEvent,
37852 &_swigt__p_wxSizer,
37853 &_swigt__p_wxSizerItem,
37854 &_swigt__p_wxSound,
37855 &_swigt__p_wxStandardPaths,
37856 &_swigt__p_wxStaticBoxSizer,
37857 &_swigt__p_wxStdDialogButtonSizer,
37858 &_swigt__p_wxStopWatch,
37859 &_swigt__p_wxString,
37860 &_swigt__p_wxSysColourChangedEvent,
37861 &_swigt__p_wxSystemOptions,
37862 &_swigt__p_wxSystemSettings,
37863 &_swigt__p_wxTIFFHandler,
37864 &_swigt__p_wxTextCtrl,
37865 &_swigt__p_wxTextDataObject,
37866 &_swigt__p_wxTimeSpan,
37867 &_swigt__p_wxTimer,
37868 &_swigt__p_wxTimerEvent,
37869 &_swigt__p_wxTimerRunner,
37870 &_swigt__p_wxTipProvider,
37871 &_swigt__p_wxToolTip,
37872 &_swigt__p_wxURLDataObject,
37873 &_swigt__p_wxUpdateUIEvent,
37874 &_swigt__p_wxValidator,
37875 &_swigt__p_wxVideoMode,
37876 &_swigt__p_wxWindow,
37877 &_swigt__p_wxWindowCreateEvent,
37878 &_swigt__p_wxWindowDestroyEvent,
37879 &_swigt__p_wxWindowDisabler,
37880 &_swigt__p_wxXPMHandler,
37881 };
37882
37883 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37884 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37885 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37886 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37887 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37888 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37889 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37890 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37891 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37892 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}};
37893 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37894 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37895 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37896 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37897 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37898 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37899 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37900 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37901 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}};
37902 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37903 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37904 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37905 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37906 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37907 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}};
37908 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37909 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}};
37910 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37911 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37912 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37913 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37914 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37915 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37916 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37917 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37918 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37919 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37920 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37921 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37922 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37923 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37924 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37925 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37926 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37927 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37928 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37929 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37930 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37931 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37932 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37933 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37934 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37935 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37936 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37937 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37938 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37939 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37940 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37941 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37942 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37943 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37944 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37945 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37946 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37947 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37948 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37949 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37950 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37951 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37952 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}};
37953 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37954 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37955 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37956 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37957 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37958 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37959 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}};
37960 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37962 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37963 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37964 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37965 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37966 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37967 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37968 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37969 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37970 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37971 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}};
37972 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37973 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37974 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37975 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37978 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37979 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37980 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37981 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37982 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38015 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}};
38016 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38021 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38024 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38025 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}};
38026 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38031 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38032 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38033 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38043 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}};
38044 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38048 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}};
38049 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38050 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38051 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38052 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}};
38053 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38054
38055 static swig_cast_info *swig_cast_initial[] = {
38056 _swigc__p_char,
38057 _swigc__p_form_ops_t,
38058 _swigc__p_int,
38059 _swigc__p_unsigned_char,
38060 _swigc__p_unsigned_int,
38061 _swigc__p_unsigned_long,
38062 _swigc__p_void,
38063 _swigc__p_wxANIHandler,
38064 _swigc__p_wxAcceleratorTable,
38065 _swigc__p_wxActivateEvent,
38066 _swigc__p_wxArrayString,
38067 _swigc__p_wxBMPHandler,
38068 _swigc__p_wxBitmap,
38069 _swigc__p_wxBitmapDataObject,
38070 _swigc__p_wxBoxSizer,
38071 _swigc__p_wxBusyCursor,
38072 _swigc__p_wxBusyInfo,
38073 _swigc__p_wxCURHandler,
38074 _swigc__p_wxCaret,
38075 _swigc__p_wxChar,
38076 _swigc__p_wxChildFocusEvent,
38077 _swigc__p_wxClipboard,
38078 _swigc__p_wxClipboardLocker,
38079 _swigc__p_wxClipboardTextEvent,
38080 _swigc__p_wxCloseEvent,
38081 _swigc__p_wxColour,
38082 _swigc__p_wxCommandEvent,
38083 _swigc__p_wxConfig,
38084 _swigc__p_wxConfigBase,
38085 _swigc__p_wxConfigPathChanger,
38086 _swigc__p_wxContextMenuEvent,
38087 _swigc__p_wxControl,
38088 _swigc__p_wxControlWithItems,
38089 _swigc__p_wxCursor,
38090 _swigc__p_wxCustomDataObject,
38091 _swigc__p_wxDC,
38092 _swigc__p_wxDataFormat,
38093 _swigc__p_wxDataObject,
38094 _swigc__p_wxDataObjectComposite,
38095 _swigc__p_wxDataObjectSimple,
38096 _swigc__p_wxDateEvent,
38097 _swigc__p_wxDateSpan,
38098 _swigc__p_wxDateTime,
38099 _swigc__p_wxDateTime__TimeZone,
38100 _swigc__p_wxDisplay,
38101 _swigc__p_wxDisplayChangedEvent,
38102 _swigc__p_wxDropFilesEvent,
38103 _swigc__p_wxDuplexMode,
38104 _swigc__p_wxEraseEvent,
38105 _swigc__p_wxEvent,
38106 _swigc__p_wxEvtHandler,
38107 _swigc__p_wxFSFile,
38108 _swigc__p_wxFileConfig,
38109 _swigc__p_wxFileDataObject,
38110 _swigc__p_wxFileHistory,
38111 _swigc__p_wxFileSystem,
38112 _swigc__p_wxFileType,
38113 _swigc__p_wxFileTypeInfo,
38114 _swigc__p_wxFlexGridSizer,
38115 _swigc__p_wxFocusEvent,
38116 _swigc__p_wxFont,
38117 _swigc__p_wxFrame,
38118 _swigc__p_wxGBSizerItem,
38119 _swigc__p_wxGIFHandler,
38120 _swigc__p_wxGridBagSizer,
38121 _swigc__p_wxGridSizer,
38122 _swigc__p_wxICOHandler,
38123 _swigc__p_wxIcon,
38124 _swigc__p_wxIconizeEvent,
38125 _swigc__p_wxIdleEvent,
38126 _swigc__p_wxImage,
38127 _swigc__p_wxImageHandler,
38128 _swigc__p_wxIndividualLayoutConstraint,
38129 _swigc__p_wxInitDialogEvent,
38130 _swigc__p_wxJPEGHandler,
38131 _swigc__p_wxJoystick,
38132 _swigc__p_wxJoystickEvent,
38133 _swigc__p_wxKeyEvent,
38134 _swigc__p_wxKillError,
38135 _swigc__p_wxLayoutConstraints,
38136 _swigc__p_wxLog,
38137 _swigc__p_wxLogBuffer,
38138 _swigc__p_wxLogChain,
38139 _swigc__p_wxLogGui,
38140 _swigc__p_wxLogNull,
38141 _swigc__p_wxLogStderr,
38142 _swigc__p_wxLogTextCtrl,
38143 _swigc__p_wxLogWindow,
38144 _swigc__p_wxMaximizeEvent,
38145 _swigc__p_wxMemorySize,
38146 _swigc__p_wxMenu,
38147 _swigc__p_wxMenuBar,
38148 _swigc__p_wxMenuEvent,
38149 _swigc__p_wxMenuItem,
38150 _swigc__p_wxMetafileDataObject,
38151 _swigc__p_wxMimeTypesManager,
38152 _swigc__p_wxMouseCaptureChangedEvent,
38153 _swigc__p_wxMouseEvent,
38154 _swigc__p_wxMouseState,
38155 _swigc__p_wxMoveEvent,
38156 _swigc__p_wxMutexGuiLocker,
38157 _swigc__p_wxNavigationKeyEvent,
38158 _swigc__p_wxNcPaintEvent,
38159 _swigc__p_wxNotifyEvent,
38160 _swigc__p_wxObject,
38161 _swigc__p_wxOutputStream,
38162 _swigc__p_wxPCXHandler,
38163 _swigc__p_wxPNGHandler,
38164 _swigc__p_wxPNMHandler,
38165 _swigc__p_wxPaintEvent,
38166 _swigc__p_wxPaletteChangedEvent,
38167 _swigc__p_wxPaperSize,
38168 _swigc__p_wxPoint,
38169 _swigc__p_wxPowerEvent,
38170 _swigc__p_wxProcessEvent,
38171 _swigc__p_wxPyApp,
38172 _swigc__p_wxPyArtProvider,
38173 _swigc__p_wxPyBitmapDataObject,
38174 _swigc__p_wxPyCommandEvent,
38175 _swigc__p_wxPyDataObjectSimple,
38176 _swigc__p_wxPyDropSource,
38177 _swigc__p_wxPyDropTarget,
38178 _swigc__p_wxPyEvent,
38179 _swigc__p_wxPyFileDropTarget,
38180 _swigc__p_wxPyImageHandler,
38181 _swigc__p_wxPyLog,
38182 _swigc__p_wxPyProcess,
38183 _swigc__p_wxPySizer,
38184 _swigc__p_wxPyTextDataObject,
38185 _swigc__p_wxPyTextDropTarget,
38186 _swigc__p_wxPyTimer,
38187 _swigc__p_wxPyTipProvider,
38188 _swigc__p_wxPyValidator,
38189 _swigc__p_wxQueryNewPaletteEvent,
38190 _swigc__p_wxRect,
38191 _swigc__p_wxScrollEvent,
38192 _swigc__p_wxScrollWinEvent,
38193 _swigc__p_wxSetCursorEvent,
38194 _swigc__p_wxShowEvent,
38195 _swigc__p_wxSingleInstanceChecker,
38196 _swigc__p_wxSize,
38197 _swigc__p_wxSizeEvent,
38198 _swigc__p_wxSizer,
38199 _swigc__p_wxSizerItem,
38200 _swigc__p_wxSound,
38201 _swigc__p_wxStandardPaths,
38202 _swigc__p_wxStaticBoxSizer,
38203 _swigc__p_wxStdDialogButtonSizer,
38204 _swigc__p_wxStopWatch,
38205 _swigc__p_wxString,
38206 _swigc__p_wxSysColourChangedEvent,
38207 _swigc__p_wxSystemOptions,
38208 _swigc__p_wxSystemSettings,
38209 _swigc__p_wxTIFFHandler,
38210 _swigc__p_wxTextCtrl,
38211 _swigc__p_wxTextDataObject,
38212 _swigc__p_wxTimeSpan,
38213 _swigc__p_wxTimer,
38214 _swigc__p_wxTimerEvent,
38215 _swigc__p_wxTimerRunner,
38216 _swigc__p_wxTipProvider,
38217 _swigc__p_wxToolTip,
38218 _swigc__p_wxURLDataObject,
38219 _swigc__p_wxUpdateUIEvent,
38220 _swigc__p_wxValidator,
38221 _swigc__p_wxVideoMode,
38222 _swigc__p_wxWindow,
38223 _swigc__p_wxWindowCreateEvent,
38224 _swigc__p_wxWindowDestroyEvent,
38225 _swigc__p_wxWindowDisabler,
38226 _swigc__p_wxXPMHandler,
38227 };
38228
38229
38230 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38231
38232 static swig_const_info swig_const_table[] = {
38233 {0, 0, 0, 0.0, 0, 0}};
38234
38235 #ifdef __cplusplus
38236 }
38237 #endif
38238 /* -----------------------------------------------------------------------------
38239 * Type initialization:
38240 * This problem is tough by the requirement that no dynamic
38241 * memory is used. Also, since swig_type_info structures store pointers to
38242 * swig_cast_info structures and swig_cast_info structures store pointers back
38243 * to swig_type_info structures, we need some lookup code at initialization.
38244 * The idea is that swig generates all the structures that are needed.
38245 * The runtime then collects these partially filled structures.
38246 * The SWIG_InitializeModule function takes these initial arrays out of
38247 * swig_module, and does all the lookup, filling in the swig_module.types
38248 * array with the correct data and linking the correct swig_cast_info
38249 * structures together.
38250 *
38251 * The generated swig_type_info structures are assigned staticly to an initial
38252 * array. We just loop though that array, and handle each type individually.
38253 * First we lookup if this type has been already loaded, and if so, use the
38254 * loaded structure instead of the generated one. Then we have to fill in the
38255 * cast linked list. The cast data is initially stored in something like a
38256 * two-dimensional array. Each row corresponds to a type (there are the same
38257 * number of rows as there are in the swig_type_initial array). Each entry in
38258 * a column is one of the swig_cast_info structures for that type.
38259 * The cast_initial array is actually an array of arrays, because each row has
38260 * a variable number of columns. So to actually build the cast linked list,
38261 * we find the array of casts associated with the type, and loop through it
38262 * adding the casts to the list. The one last trick we need to do is making
38263 * sure the type pointer in the swig_cast_info struct is correct.
38264 *
38265 * First off, we lookup the cast->type name to see if it is already loaded.
38266 * There are three cases to handle:
38267 * 1) If the cast->type has already been loaded AND the type we are adding
38268 * casting info to has not been loaded (it is in this module), THEN we
38269 * replace the cast->type pointer with the type pointer that has already
38270 * been loaded.
38271 * 2) If BOTH types (the one we are adding casting info to, and the
38272 * cast->type) are loaded, THEN the cast info has already been loaded by
38273 * the previous module so we just ignore it.
38274 * 3) Finally, if cast->type has not already been loaded, then we add that
38275 * swig_cast_info to the linked list (because the cast->type) pointer will
38276 * be correct.
38277 * ----------------------------------------------------------------------------- */
38278
38279 #ifdef __cplusplus
38280 extern "C" {
38281 #if 0
38282 } /* c-mode */
38283 #endif
38284 #endif
38285
38286 #if 0
38287 #define SWIGRUNTIME_DEBUG
38288 #endif
38289
38290 SWIGRUNTIME void
38291 SWIG_InitializeModule(void *clientdata) {
38292 size_t i;
38293 swig_module_info *module_head;
38294 static int init_run = 0;
38295
38296 clientdata = clientdata;
38297
38298 if (init_run) return;
38299 init_run = 1;
38300
38301 /* Initialize the swig_module */
38302 swig_module.type_initial = swig_type_initial;
38303 swig_module.cast_initial = swig_cast_initial;
38304
38305 /* Try and load any already created modules */
38306 module_head = SWIG_GetModule(clientdata);
38307 if (module_head) {
38308 swig_module.next = module_head->next;
38309 module_head->next = &swig_module;
38310 } else {
38311 /* This is the first module loaded */
38312 swig_module.next = &swig_module;
38313 SWIG_SetModule(clientdata, &swig_module);
38314 }
38315
38316 /* Now work on filling in swig_module.types */
38317 #ifdef SWIGRUNTIME_DEBUG
38318 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38319 #endif
38320 for (i = 0; i < swig_module.size; ++i) {
38321 swig_type_info *type = 0;
38322 swig_type_info *ret;
38323 swig_cast_info *cast;
38324
38325 #ifdef SWIGRUNTIME_DEBUG
38326 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38327 #endif
38328
38329 /* if there is another module already loaded */
38330 if (swig_module.next != &swig_module) {
38331 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38332 }
38333 if (type) {
38334 /* Overwrite clientdata field */
38335 #ifdef SWIGRUNTIME_DEBUG
38336 printf("SWIG_InitializeModule: found type %s\n", type->name);
38337 #endif
38338 if (swig_module.type_initial[i]->clientdata) {
38339 type->clientdata = swig_module.type_initial[i]->clientdata;
38340 #ifdef SWIGRUNTIME_DEBUG
38341 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38342 #endif
38343 }
38344 } else {
38345 type = swig_module.type_initial[i];
38346 }
38347
38348 /* Insert casting types */
38349 cast = swig_module.cast_initial[i];
38350 while (cast->type) {
38351 /* Don't need to add information already in the list */
38352 ret = 0;
38353 #ifdef SWIGRUNTIME_DEBUG
38354 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38355 #endif
38356 if (swig_module.next != &swig_module) {
38357 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38358 #ifdef SWIGRUNTIME_DEBUG
38359 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38360 #endif
38361 }
38362 if (ret) {
38363 if (type == swig_module.type_initial[i]) {
38364 #ifdef SWIGRUNTIME_DEBUG
38365 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38366 #endif
38367 cast->type = ret;
38368 ret = 0;
38369 } else {
38370 /* Check for casting already in the list */
38371 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38372 #ifdef SWIGRUNTIME_DEBUG
38373 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38374 #endif
38375 if (!ocast) ret = 0;
38376 }
38377 }
38378
38379 if (!ret) {
38380 #ifdef SWIGRUNTIME_DEBUG
38381 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38382 #endif
38383 if (type->cast) {
38384 type->cast->prev = cast;
38385 cast->next = type->cast;
38386 }
38387 type->cast = cast;
38388 }
38389 cast++;
38390 }
38391 /* Set entry in modules->types array equal to the type */
38392 swig_module.types[i] = type;
38393 }
38394 swig_module.types[i] = 0;
38395
38396 #ifdef SWIGRUNTIME_DEBUG
38397 printf("**** SWIG_InitializeModule: Cast List ******\n");
38398 for (i = 0; i < swig_module.size; ++i) {
38399 int j = 0;
38400 swig_cast_info *cast = swig_module.cast_initial[i];
38401 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38402 while (cast->type) {
38403 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38404 cast++;
38405 ++j;
38406 }
38407 printf("---- Total casts: %d\n",j);
38408 }
38409 printf("**** SWIG_InitializeModule: Cast List ******\n");
38410 #endif
38411 }
38412
38413 /* This function will propagate the clientdata field of type to
38414 * any new swig_type_info structures that have been added into the list
38415 * of equivalent types. It is like calling
38416 * SWIG_TypeClientData(type, clientdata) a second time.
38417 */
38418 SWIGRUNTIME void
38419 SWIG_PropagateClientData(void) {
38420 size_t i;
38421 swig_cast_info *equiv;
38422 static int init_run = 0;
38423
38424 if (init_run) return;
38425 init_run = 1;
38426
38427 for (i = 0; i < swig_module.size; i++) {
38428 if (swig_module.types[i]->clientdata) {
38429 equiv = swig_module.types[i]->cast;
38430 while (equiv) {
38431 if (!equiv->converter) {
38432 if (equiv->type && !equiv->type->clientdata)
38433 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38434 }
38435 equiv = equiv->next;
38436 }
38437 }
38438 }
38439 }
38440
38441 #ifdef __cplusplus
38442 #if 0
38443 {
38444 /* c-mode */
38445 #endif
38446 }
38447 #endif
38448
38449
38450
38451 #ifdef __cplusplus
38452 extern "C" {
38453 #endif
38454
38455 /* Python-specific SWIG API */
38456 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38457 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38458 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38459
38460 /* -----------------------------------------------------------------------------
38461 * global variable support code.
38462 * ----------------------------------------------------------------------------- */
38463
38464 typedef struct swig_globalvar {
38465 char *name; /* Name of global variable */
38466 PyObject *(*get_attr)(void); /* Return the current value */
38467 int (*set_attr)(PyObject *); /* Set the value */
38468 struct swig_globalvar *next;
38469 } swig_globalvar;
38470
38471 typedef struct swig_varlinkobject {
38472 PyObject_HEAD
38473 swig_globalvar *vars;
38474 } swig_varlinkobject;
38475
38476 SWIGINTERN PyObject *
38477 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38478 return PyString_FromString("<Swig global variables>");
38479 }
38480
38481 SWIGINTERN PyObject *
38482 swig_varlink_str(swig_varlinkobject *v) {
38483 PyObject *str = PyString_FromString("(");
38484 swig_globalvar *var;
38485 for (var = v->vars; var; var=var->next) {
38486 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38487 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38488 }
38489 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38490 return str;
38491 }
38492
38493 SWIGINTERN int
38494 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38495 PyObject *str = swig_varlink_str(v);
38496 fprintf(fp,"Swig global variables ");
38497 fprintf(fp,"%s\n", PyString_AsString(str));
38498 Py_DECREF(str);
38499 return 0;
38500 }
38501
38502 SWIGINTERN void
38503 swig_varlink_dealloc(swig_varlinkobject *v) {
38504 swig_globalvar *var = v->vars;
38505 while (var) {
38506 swig_globalvar *n = var->next;
38507 free(var->name);
38508 free(var);
38509 var = n;
38510 }
38511 }
38512
38513 SWIGINTERN PyObject *
38514 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38515 PyObject *res = NULL;
38516 swig_globalvar *var = v->vars;
38517 while (var) {
38518 if (strcmp(var->name,n) == 0) {
38519 res = (*var->get_attr)();
38520 break;
38521 }
38522 var = var->next;
38523 }
38524 if (res == NULL && !PyErr_Occurred()) {
38525 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38526 }
38527 return res;
38528 }
38529
38530 SWIGINTERN int
38531 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38532 int res = 1;
38533 swig_globalvar *var = v->vars;
38534 while (var) {
38535 if (strcmp(var->name,n) == 0) {
38536 res = (*var->set_attr)(p);
38537 break;
38538 }
38539 var = var->next;
38540 }
38541 if (res == 1 && !PyErr_Occurred()) {
38542 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38543 }
38544 return res;
38545 }
38546
38547 SWIGINTERN PyTypeObject*
38548 swig_varlink_type(void) {
38549 static char varlink__doc__[] = "Swig var link object";
38550 static PyTypeObject varlink_type;
38551 static int type_init = 0;
38552 if (!type_init) {
38553 const PyTypeObject tmp
38554 = {
38555 PyObject_HEAD_INIT(NULL)
38556 0, /* Number of items in variable part (ob_size) */
38557 (char *)"swigvarlink", /* Type name (tp_name) */
38558 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38559 0, /* Itemsize (tp_itemsize) */
38560 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38561 (printfunc) swig_varlink_print, /* Print (tp_print) */
38562 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38563 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38564 0, /* tp_compare */
38565 (reprfunc) swig_varlink_repr, /* tp_repr */
38566 0, /* tp_as_number */
38567 0, /* tp_as_sequence */
38568 0, /* tp_as_mapping */
38569 0, /* tp_hash */
38570 0, /* tp_call */
38571 (reprfunc)swig_varlink_str, /* tp_str */
38572 0, /* tp_getattro */
38573 0, /* tp_setattro */
38574 0, /* tp_as_buffer */
38575 0, /* tp_flags */
38576 varlink__doc__, /* tp_doc */
38577 0, /* tp_traverse */
38578 0, /* tp_clear */
38579 0, /* tp_richcompare */
38580 0, /* tp_weaklistoffset */
38581 #if PY_VERSION_HEX >= 0x02020000
38582 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38583 #endif
38584 #if PY_VERSION_HEX >= 0x02030000
38585 0, /* tp_del */
38586 #endif
38587 #ifdef COUNT_ALLOCS
38588 0,0,0,0 /* tp_alloc -> tp_next */
38589 #endif
38590 };
38591 varlink_type = tmp;
38592 varlink_type.ob_type = &PyType_Type;
38593 type_init = 1;
38594 }
38595 return &varlink_type;
38596 }
38597
38598 /* Create a variable linking object for use later */
38599 SWIGINTERN PyObject *
38600 SWIG_Python_newvarlink(void) {
38601 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38602 if (result) {
38603 result->vars = 0;
38604 }
38605 return ((PyObject*) result);
38606 }
38607
38608 SWIGINTERN void
38609 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38610 swig_varlinkobject *v = (swig_varlinkobject *) p;
38611 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38612 if (gv) {
38613 size_t size = strlen(name)+1;
38614 gv->name = (char *)malloc(size);
38615 if (gv->name) {
38616 strncpy(gv->name,name,size);
38617 gv->get_attr = get_attr;
38618 gv->set_attr = set_attr;
38619 gv->next = v->vars;
38620 }
38621 }
38622 v->vars = gv;
38623 }
38624
38625 SWIGINTERN PyObject *
38626 SWIG_globals() {
38627 static PyObject *_SWIG_globals = 0;
38628 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38629 return _SWIG_globals;
38630 }
38631
38632 /* -----------------------------------------------------------------------------
38633 * constants/methods manipulation
38634 * ----------------------------------------------------------------------------- */
38635
38636 /* Install Constants */
38637 SWIGINTERN void
38638 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38639 PyObject *obj = 0;
38640 size_t i;
38641 for (i = 0; constants[i].type; ++i) {
38642 switch(constants[i].type) {
38643 case SWIG_PY_POINTER:
38644 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38645 break;
38646 case SWIG_PY_BINARY:
38647 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38648 break;
38649 default:
38650 obj = 0;
38651 break;
38652 }
38653 if (obj) {
38654 PyDict_SetItemString(d, constants[i].name, obj);
38655 Py_DECREF(obj);
38656 }
38657 }
38658 }
38659
38660 /* -----------------------------------------------------------------------------*/
38661 /* Fix SwigMethods to carry the callback ptrs when needed */
38662 /* -----------------------------------------------------------------------------*/
38663
38664 SWIGINTERN void
38665 SWIG_Python_FixMethods(PyMethodDef *methods,
38666 swig_const_info *const_table,
38667 swig_type_info **types,
38668 swig_type_info **types_initial) {
38669 size_t i;
38670 for (i = 0; methods[i].ml_name; ++i) {
38671 const char *c = methods[i].ml_doc;
38672 if (c && (c = strstr(c, "swig_ptr: "))) {
38673 int j;
38674 swig_const_info *ci = 0;
38675 const char *name = c + 10;
38676 for (j = 0; const_table[j].type; ++j) {
38677 if (strncmp(const_table[j].name, name,
38678 strlen(const_table[j].name)) == 0) {
38679 ci = &(const_table[j]);
38680 break;
38681 }
38682 }
38683 if (ci) {
38684 size_t shift = (ci->ptype) - types;
38685 swig_type_info *ty = types_initial[shift];
38686 size_t ldoc = (c - methods[i].ml_doc);
38687 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38688 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38689 if (ndoc) {
38690 char *buff = ndoc;
38691 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38692 if (ptr) {
38693 strncpy(buff, methods[i].ml_doc, ldoc);
38694 buff += ldoc;
38695 strncpy(buff, "swig_ptr: ", 10);
38696 buff += 10;
38697 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38698 methods[i].ml_doc = ndoc;
38699 }
38700 }
38701 }
38702 }
38703 }
38704 }
38705
38706 #ifdef __cplusplus
38707 }
38708 #endif
38709
38710 /* -----------------------------------------------------------------------------*
38711 * Partial Init method
38712 * -----------------------------------------------------------------------------*/
38713
38714 #ifdef __cplusplus
38715 extern "C"
38716 #endif
38717 SWIGEXPORT void SWIG_init(void) {
38718 PyObject *m, *d;
38719
38720 /* Fix SwigMethods to carry the callback ptrs when needed */
38721 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38722
38723 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38724 d = PyModule_GetDict(m);
38725
38726 SWIG_InitializeModule(0);
38727 SWIG_InstallConstants(d,swig_const_table);
38728
38729
38730 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38731 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38732 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38733 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38734 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38735 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38736 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38737 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38738 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38739 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38740 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38741 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38742 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38743 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38744 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38745 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38746 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38747 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38748 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38749 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38750 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38751 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38752 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38753 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38754 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38755 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38756 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38757 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38758 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38759 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38760 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38761 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38762 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38763 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38764 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38765 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38766 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38767 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38768 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38769 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38770 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38771 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38772 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38773 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38774 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38775 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38776 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38777 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38778 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38779 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38780 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38781 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38782 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38783 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38784 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38785 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38786 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38787 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38788 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38789 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38790 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38791 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38792 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38793 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38794 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38795 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38796 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38797 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38798 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38799 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38800 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38801 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38802 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38803 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38804 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38805 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38806 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38807 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38808 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38809 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38810 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38811 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38812 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38813 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38814 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38815 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38816 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38817 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38818 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38819 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38820 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38821 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38822 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38823 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38824 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38825 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38826 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38827 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
38828 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
38829 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
38830 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
38831 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
38832 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
38833 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
38834 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
38835 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
38836 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
38837 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
38838 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
38839 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
38840 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
38841 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
38842 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
38843 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
38844 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
38845 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
38846 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
38847 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
38848 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
38849 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
38850 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
38851 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
38852 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
38853 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
38854 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
38855 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
38856 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
38857 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
38858 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
38859 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
38860 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
38861 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
38862 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38863 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38864 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38865 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38866 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38867
38868 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38869
38870 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38871 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38872 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38873 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38874 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38875 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38876 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38877 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38878 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38879 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38880 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38881 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38882 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38883 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38884 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38885 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38886 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38887 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38888 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38889 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38890 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38891 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38892 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38893 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38894 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38895 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38896 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38897 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38898 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38899 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38900 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38901 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38902 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38903 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38904 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38905 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38906 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38907 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38908 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38909 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38910 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38911 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38912 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38913 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38914 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38915 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38916 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38917 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38918 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38919 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38920 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38921 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38922 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38923
38924 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38925
38926 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38927 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38928 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38929 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38930 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38931 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38932 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38933 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38934 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38935 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38936 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38937 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38938 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38939 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38940 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38941 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38942 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38943 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38944 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38945 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38946 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38947 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38948 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38949 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38950 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38951 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38952 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38953 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38954 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38955 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38956 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38957 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38958 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38959 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38960 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38961 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38962 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38963 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38964 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38965 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38966 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38967 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38968 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38969 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38970 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38971 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38972 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38973 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38974 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38975 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38976 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38977 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38978 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38979 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38980 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38981 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38982 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38983 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38984 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38985 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38986 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38987 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38988 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38989 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38990 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38991 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38992 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38993 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38994 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38995 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38996 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38997 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38998 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38999 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39000 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39001 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39002
39003 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39004
39005 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39006 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39007 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39008 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39009 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39010 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39011 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39012 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39013 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39014 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39016 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39017 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39018 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39019 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39020 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39021 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39022 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39023 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39024 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39025 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39026 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39027 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39028 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39029 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39030 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39031 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39032 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39033 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39034 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39035 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39036 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39037 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39038 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39039 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39040 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39041 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39042 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39043 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39044 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39045 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39046 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39047 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39048 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39049 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39050 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39051 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39052 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39053 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39054 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39055 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39056 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39057 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39058 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39059 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39060 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39061 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39062 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39063 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39064 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39065 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39066 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39067 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39068 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39069 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39070 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39071 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39072 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39073 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39074 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39075 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39076 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39077 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39078 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39079 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39080 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39081 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39082 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39083 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39084 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39085 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39086 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39087 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39088 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39089 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39090 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39091 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39092 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39093 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39094 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39095 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39096 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39097 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39098 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39099 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39100 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39101 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39102 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39103 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39104 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39105 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39106 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39107 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39108 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39109 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39110 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39111 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39112 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39113 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39114 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39115 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39116 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39117 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39118 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39119 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39120 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39121 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39122 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39123 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39124 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39125 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39126 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39127 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39128 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39129 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39130 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39131 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39132 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39133 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39134 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39135 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39136 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39137 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39138 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39139 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39140 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39141 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39142 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39143 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39144 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39145 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39146 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39147 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39148 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39149 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39150 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39151 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39152 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39153 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39154 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39155 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39156 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39157 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39158 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39159 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39160 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39161 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39162 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39163 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39164 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39165 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39166 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39167 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39168 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39169 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39170 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39171 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39172 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39173 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39174 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39175 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39176 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39177 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39178 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39179 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39180 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39181 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39182 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39183 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39184 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39185 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39186 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39187 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39188 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39189 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39190 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39191 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39192 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39193 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39194 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39195 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39196 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39197 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39198 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39199 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39200 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39201 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39202 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39203 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39204 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39205
39206 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39207 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39208 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39209 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39210
39211 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39212 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39213 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39214 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39215 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39216 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39217 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39218 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39219 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39220 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39221 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39222 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39223 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39224 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39225 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39226 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39227 }
39228
wxWidgets (Impactor)